strongdm.models

View Source
    0# Copyright 2020 StrongDM Inc
    1#
    2# Licensed under the Apache License, Version 2.0 (the "License");
    3# you may not use this file except in compliance with the License.
    4# You may obtain a copy of the License at
    5#
    6#     http://www.apache.org/licenses/LICENSE-2.0
    7#
    8# Unless required by applicable law or agreed to in writing, software
    9# distributed under the License is distributed on an "AS IS" BASIS,
   10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   11# See the License for the specific language governing permissions and
   12# limitations under the License.
   13#
   14
   15# This file was generated by protogen. DO NOT EDIT.
   16
   17import collections
   18
   19
   20class AKS:
   21    '''
   22
   23    '''
   24    __slots__ = [
   25        'certificate_authority',
   26        'client_certificate',
   27        'client_key',
   28        'egress_filter',
   29        'healthcheck_namespace',
   30        'healthy',
   31        'hostname',
   32        'id',
   33        'name',
   34        'port',
   35        'secret_store_id',
   36        'tags',
   37    ]
   38
   39    def __init__(
   40        self,
   41        certificate_authority=None,
   42        client_certificate=None,
   43        client_key=None,
   44        egress_filter=None,
   45        healthcheck_namespace=None,
   46        healthy=None,
   47        hostname=None,
   48        id=None,
   49        name=None,
   50        port=None,
   51        secret_store_id=None,
   52        tags=None,
   53    ):
   54        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   55        '''
   56
   57        '''
   58        self.client_certificate = client_certificate if client_certificate is not None else ''
   59        '''
   60
   61        '''
   62        self.client_key = client_key if client_key is not None else ''
   63        '''
   64
   65        '''
   66        self.egress_filter = egress_filter if egress_filter is not None else ''
   67        '''
   68         A filter applied to the routing logic to pin datasource to nodes.
   69        '''
   70        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   71        '''
   72         The path used to check the health of your connection.  Defaults to `default`.
   73        '''
   74        self.healthy = healthy if healthy is not None else False
   75        '''
   76         True if the datasource is reachable and the credentials are valid.
   77        '''
   78        self.hostname = hostname if hostname is not None else ''
   79        '''
   80
   81        '''
   82        self.id = id if id is not None else ''
   83        '''
   84         Unique identifier of the Resource.
   85        '''
   86        self.name = name if name is not None else ''
   87        '''
   88         Unique human-readable name of the Resource.
   89        '''
   90        self.port = port if port is not None else 0
   91        '''
   92
   93        '''
   94        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   95        '''
   96         ID of the secret store containing credentials for this resource, if any.
   97        '''
   98        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   99        '''
  100         Tags is a map of key, value pairs.
  101        '''
  102
  103    def __repr__(self):
  104        return '<sdm.AKS ' + \
  105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  107            'client_key: ' + repr(self.client_key) + ' ' +\
  108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  110            'healthy: ' + repr(self.healthy) + ' ' +\
  111            'hostname: ' + repr(self.hostname) + ' ' +\
  112            'id: ' + repr(self.id) + ' ' +\
  113            'name: ' + repr(self.name) + ' ' +\
  114            'port: ' + repr(self.port) + ' ' +\
  115            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  116            'tags: ' + repr(self.tags) + ' ' +\
  117            '>'
  118
  119    def to_dict(self):
  120        return {
  121            'certificate_authority': self.certificate_authority,
  122            'client_certificate': self.client_certificate,
  123            'client_key': self.client_key,
  124            'egress_filter': self.egress_filter,
  125            'healthcheck_namespace': self.healthcheck_namespace,
  126            'healthy': self.healthy,
  127            'hostname': self.hostname,
  128            'id': self.id,
  129            'name': self.name,
  130            'port': self.port,
  131            'secret_store_id': self.secret_store_id,
  132            'tags': self.tags,
  133        }
  134
  135    @classmethod
  136    def from_dict(cls, d):
  137        return cls(
  138            certificate_authority=d.get('certificate_authority'),
  139            client_certificate=d.get('client_certificate'),
  140            client_key=d.get('client_key'),
  141            egress_filter=d.get('egress_filter'),
  142            healthcheck_namespace=d.get('healthcheck_namespace'),
  143            healthy=d.get('healthy'),
  144            hostname=d.get('hostname'),
  145            id=d.get('id'),
  146            name=d.get('name'),
  147            port=d.get('port'),
  148            secret_store_id=d.get('secret_store_id'),
  149            tags=d.get('tags'),
  150        )
  151
  152
  153class AKSBasicAuth:
  154    '''
  155
  156    '''
  157    __slots__ = [
  158        'egress_filter',
  159        'healthcheck_namespace',
  160        'healthy',
  161        'hostname',
  162        'id',
  163        'name',
  164        'password',
  165        'port',
  166        'secret_store_id',
  167        'tags',
  168        'username',
  169    ]
  170
  171    def __init__(
  172        self,
  173        egress_filter=None,
  174        healthcheck_namespace=None,
  175        healthy=None,
  176        hostname=None,
  177        id=None,
  178        name=None,
  179        password=None,
  180        port=None,
  181        secret_store_id=None,
  182        tags=None,
  183        username=None,
  184    ):
  185        self.egress_filter = egress_filter if egress_filter is not None else ''
  186        '''
  187         A filter applied to the routing logic to pin datasource to nodes.
  188        '''
  189        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  190        '''
  191         The path used to check the health of your connection.  Defaults to `default`.
  192        '''
  193        self.healthy = healthy if healthy is not None else False
  194        '''
  195         True if the datasource is reachable and the credentials are valid.
  196        '''
  197        self.hostname = hostname if hostname is not None else ''
  198        '''
  199
  200        '''
  201        self.id = id if id is not None else ''
  202        '''
  203         Unique identifier of the Resource.
  204        '''
  205        self.name = name if name is not None else ''
  206        '''
  207         Unique human-readable name of the Resource.
  208        '''
  209        self.password = password if password is not None else ''
  210        '''
  211
  212        '''
  213        self.port = port if port is not None else 0
  214        '''
  215
  216        '''
  217        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  218        '''
  219         ID of the secret store containing credentials for this resource, if any.
  220        '''
  221        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  222        '''
  223         Tags is a map of key, value pairs.
  224        '''
  225        self.username = username if username is not None else ''
  226        '''
  227
  228        '''
  229
  230    def __repr__(self):
  231        return '<sdm.AKSBasicAuth ' + \
  232            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  233            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  234            'healthy: ' + repr(self.healthy) + ' ' +\
  235            'hostname: ' + repr(self.hostname) + ' ' +\
  236            'id: ' + repr(self.id) + ' ' +\
  237            'name: ' + repr(self.name) + ' ' +\
  238            'password: ' + repr(self.password) + ' ' +\
  239            'port: ' + repr(self.port) + ' ' +\
  240            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  241            'tags: ' + repr(self.tags) + ' ' +\
  242            'username: ' + repr(self.username) + ' ' +\
  243            '>'
  244
  245    def to_dict(self):
  246        return {
  247            'egress_filter': self.egress_filter,
  248            'healthcheck_namespace': self.healthcheck_namespace,
  249            'healthy': self.healthy,
  250            'hostname': self.hostname,
  251            'id': self.id,
  252            'name': self.name,
  253            'password': self.password,
  254            'port': self.port,
  255            'secret_store_id': self.secret_store_id,
  256            'tags': self.tags,
  257            'username': self.username,
  258        }
  259
  260    @classmethod
  261    def from_dict(cls, d):
  262        return cls(
  263            egress_filter=d.get('egress_filter'),
  264            healthcheck_namespace=d.get('healthcheck_namespace'),
  265            healthy=d.get('healthy'),
  266            hostname=d.get('hostname'),
  267            id=d.get('id'),
  268            name=d.get('name'),
  269            password=d.get('password'),
  270            port=d.get('port'),
  271            secret_store_id=d.get('secret_store_id'),
  272            tags=d.get('tags'),
  273            username=d.get('username'),
  274        )
  275
  276
  277class AKSServiceAccount:
  278    '''
  279
  280    '''
  281    __slots__ = [
  282        'egress_filter',
  283        'healthcheck_namespace',
  284        'healthy',
  285        'hostname',
  286        'id',
  287        'name',
  288        'port',
  289        'secret_store_id',
  290        'tags',
  291        'token',
  292    ]
  293
  294    def __init__(
  295        self,
  296        egress_filter=None,
  297        healthcheck_namespace=None,
  298        healthy=None,
  299        hostname=None,
  300        id=None,
  301        name=None,
  302        port=None,
  303        secret_store_id=None,
  304        tags=None,
  305        token=None,
  306    ):
  307        self.egress_filter = egress_filter if egress_filter is not None else ''
  308        '''
  309         A filter applied to the routing logic to pin datasource to nodes.
  310        '''
  311        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  312        '''
  313         The path used to check the health of your connection.  Defaults to `default`.
  314        '''
  315        self.healthy = healthy if healthy is not None else False
  316        '''
  317         True if the datasource is reachable and the credentials are valid.
  318        '''
  319        self.hostname = hostname if hostname is not None else ''
  320        '''
  321
  322        '''
  323        self.id = id if id is not None else ''
  324        '''
  325         Unique identifier of the Resource.
  326        '''
  327        self.name = name if name is not None else ''
  328        '''
  329         Unique human-readable name of the Resource.
  330        '''
  331        self.port = port if port is not None else 0
  332        '''
  333
  334        '''
  335        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  336        '''
  337         ID of the secret store containing credentials for this resource, if any.
  338        '''
  339        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  340        '''
  341         Tags is a map of key, value pairs.
  342        '''
  343        self.token = token if token is not None else ''
  344        '''
  345
  346        '''
  347
  348    def __repr__(self):
  349        return '<sdm.AKSServiceAccount ' + \
  350            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  351            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  352            'healthy: ' + repr(self.healthy) + ' ' +\
  353            'hostname: ' + repr(self.hostname) + ' ' +\
  354            'id: ' + repr(self.id) + ' ' +\
  355            'name: ' + repr(self.name) + ' ' +\
  356            'port: ' + repr(self.port) + ' ' +\
  357            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  358            'tags: ' + repr(self.tags) + ' ' +\
  359            'token: ' + repr(self.token) + ' ' +\
  360            '>'
  361
  362    def to_dict(self):
  363        return {
  364            'egress_filter': self.egress_filter,
  365            'healthcheck_namespace': self.healthcheck_namespace,
  366            'healthy': self.healthy,
  367            'hostname': self.hostname,
  368            'id': self.id,
  369            'name': self.name,
  370            'port': self.port,
  371            'secret_store_id': self.secret_store_id,
  372            'tags': self.tags,
  373            'token': self.token,
  374        }
  375
  376    @classmethod
  377    def from_dict(cls, d):
  378        return cls(
  379            egress_filter=d.get('egress_filter'),
  380            healthcheck_namespace=d.get('healthcheck_namespace'),
  381            healthy=d.get('healthy'),
  382            hostname=d.get('hostname'),
  383            id=d.get('id'),
  384            name=d.get('name'),
  385            port=d.get('port'),
  386            secret_store_id=d.get('secret_store_id'),
  387            tags=d.get('tags'),
  388            token=d.get('token'),
  389        )
  390
  391
  392class AKSServiceAccountUserImpersonation:
  393    '''
  394
  395    '''
  396    __slots__ = [
  397        'egress_filter',
  398        'healthcheck_namespace',
  399        'healthy',
  400        'hostname',
  401        'id',
  402        'name',
  403        'port',
  404        'secret_store_id',
  405        'tags',
  406        'token',
  407    ]
  408
  409    def __init__(
  410        self,
  411        egress_filter=None,
  412        healthcheck_namespace=None,
  413        healthy=None,
  414        hostname=None,
  415        id=None,
  416        name=None,
  417        port=None,
  418        secret_store_id=None,
  419        tags=None,
  420        token=None,
  421    ):
  422        self.egress_filter = egress_filter if egress_filter is not None else ''
  423        '''
  424         A filter applied to the routing logic to pin datasource to nodes.
  425        '''
  426        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  427        '''
  428         The path used to check the health of your connection.  Defaults to `default`.
  429        '''
  430        self.healthy = healthy if healthy is not None else False
  431        '''
  432         True if the datasource is reachable and the credentials are valid.
  433        '''
  434        self.hostname = hostname if hostname is not None else ''
  435        '''
  436
  437        '''
  438        self.id = id if id is not None else ''
  439        '''
  440         Unique identifier of the Resource.
  441        '''
  442        self.name = name if name is not None else ''
  443        '''
  444         Unique human-readable name of the Resource.
  445        '''
  446        self.port = port if port is not None else 0
  447        '''
  448
  449        '''
  450        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  451        '''
  452         ID of the secret store containing credentials for this resource, if any.
  453        '''
  454        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  455        '''
  456         Tags is a map of key, value pairs.
  457        '''
  458        self.token = token if token is not None else ''
  459        '''
  460
  461        '''
  462
  463    def __repr__(self):
  464        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  465            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  466            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  467            'healthy: ' + repr(self.healthy) + ' ' +\
  468            'hostname: ' + repr(self.hostname) + ' ' +\
  469            'id: ' + repr(self.id) + ' ' +\
  470            'name: ' + repr(self.name) + ' ' +\
  471            'port: ' + repr(self.port) + ' ' +\
  472            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  473            'tags: ' + repr(self.tags) + ' ' +\
  474            'token: ' + repr(self.token) + ' ' +\
  475            '>'
  476
  477    def to_dict(self):
  478        return {
  479            'egress_filter': self.egress_filter,
  480            'healthcheck_namespace': self.healthcheck_namespace,
  481            'healthy': self.healthy,
  482            'hostname': self.hostname,
  483            'id': self.id,
  484            'name': self.name,
  485            'port': self.port,
  486            'secret_store_id': self.secret_store_id,
  487            'tags': self.tags,
  488            'token': self.token,
  489        }
  490
  491    @classmethod
  492    def from_dict(cls, d):
  493        return cls(
  494            egress_filter=d.get('egress_filter'),
  495            healthcheck_namespace=d.get('healthcheck_namespace'),
  496            healthy=d.get('healthy'),
  497            hostname=d.get('hostname'),
  498            id=d.get('id'),
  499            name=d.get('name'),
  500            port=d.get('port'),
  501            secret_store_id=d.get('secret_store_id'),
  502            tags=d.get('tags'),
  503            token=d.get('token'),
  504        )
  505
  506
  507class AKSUserImpersonation:
  508    '''
  509
  510    '''
  511    __slots__ = [
  512        'certificate_authority',
  513        'client_certificate',
  514        'client_key',
  515        'egress_filter',
  516        'healthcheck_namespace',
  517        'healthy',
  518        'hostname',
  519        'id',
  520        'name',
  521        'port',
  522        'secret_store_id',
  523        'tags',
  524    ]
  525
  526    def __init__(
  527        self,
  528        certificate_authority=None,
  529        client_certificate=None,
  530        client_key=None,
  531        egress_filter=None,
  532        healthcheck_namespace=None,
  533        healthy=None,
  534        hostname=None,
  535        id=None,
  536        name=None,
  537        port=None,
  538        secret_store_id=None,
  539        tags=None,
  540    ):
  541        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  542        '''
  543
  544        '''
  545        self.client_certificate = client_certificate if client_certificate is not None else ''
  546        '''
  547
  548        '''
  549        self.client_key = client_key if client_key is not None else ''
  550        '''
  551
  552        '''
  553        self.egress_filter = egress_filter if egress_filter is not None else ''
  554        '''
  555         A filter applied to the routing logic to pin datasource to nodes.
  556        '''
  557        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  558        '''
  559         The path used to check the health of your connection.  Defaults to `default`.
  560        '''
  561        self.healthy = healthy if healthy is not None else False
  562        '''
  563         True if the datasource is reachable and the credentials are valid.
  564        '''
  565        self.hostname = hostname if hostname is not None else ''
  566        '''
  567
  568        '''
  569        self.id = id if id is not None else ''
  570        '''
  571         Unique identifier of the Resource.
  572        '''
  573        self.name = name if name is not None else ''
  574        '''
  575         Unique human-readable name of the Resource.
  576        '''
  577        self.port = port if port is not None else 0
  578        '''
  579
  580        '''
  581        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  582        '''
  583         ID of the secret store containing credentials for this resource, if any.
  584        '''
  585        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  586        '''
  587         Tags is a map of key, value pairs.
  588        '''
  589
  590    def __repr__(self):
  591        return '<sdm.AKSUserImpersonation ' + \
  592            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  593            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  594            'client_key: ' + repr(self.client_key) + ' ' +\
  595            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  596            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  597            'healthy: ' + repr(self.healthy) + ' ' +\
  598            'hostname: ' + repr(self.hostname) + ' ' +\
  599            'id: ' + repr(self.id) + ' ' +\
  600            'name: ' + repr(self.name) + ' ' +\
  601            'port: ' + repr(self.port) + ' ' +\
  602            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  603            'tags: ' + repr(self.tags) + ' ' +\
  604            '>'
  605
  606    def to_dict(self):
  607        return {
  608            'certificate_authority': self.certificate_authority,
  609            'client_certificate': self.client_certificate,
  610            'client_key': self.client_key,
  611            'egress_filter': self.egress_filter,
  612            'healthcheck_namespace': self.healthcheck_namespace,
  613            'healthy': self.healthy,
  614            'hostname': self.hostname,
  615            'id': self.id,
  616            'name': self.name,
  617            'port': self.port,
  618            'secret_store_id': self.secret_store_id,
  619            'tags': self.tags,
  620        }
  621
  622    @classmethod
  623    def from_dict(cls, d):
  624        return cls(
  625            certificate_authority=d.get('certificate_authority'),
  626            client_certificate=d.get('client_certificate'),
  627            client_key=d.get('client_key'),
  628            egress_filter=d.get('egress_filter'),
  629            healthcheck_namespace=d.get('healthcheck_namespace'),
  630            healthy=d.get('healthy'),
  631            hostname=d.get('hostname'),
  632            id=d.get('id'),
  633            name=d.get('name'),
  634            port=d.get('port'),
  635            secret_store_id=d.get('secret_store_id'),
  636            tags=d.get('tags'),
  637        )
  638
  639
  640class AWS:
  641    '''
  642
  643    '''
  644    __slots__ = [
  645        'access_key',
  646        'egress_filter',
  647        'healthcheck_region',
  648        'healthy',
  649        'id',
  650        'name',
  651        'role_arn',
  652        'role_external_id',
  653        'secret_access_key',
  654        'secret_store_id',
  655        'tags',
  656    ]
  657
  658    def __init__(
  659        self,
  660        access_key=None,
  661        egress_filter=None,
  662        healthcheck_region=None,
  663        healthy=None,
  664        id=None,
  665        name=None,
  666        role_arn=None,
  667        role_external_id=None,
  668        secret_access_key=None,
  669        secret_store_id=None,
  670        tags=None,
  671    ):
  672        self.access_key = access_key if access_key is not None else ''
  673        '''
  674
  675        '''
  676        self.egress_filter = egress_filter if egress_filter is not None else ''
  677        '''
  678         A filter applied to the routing logic to pin datasource to nodes.
  679        '''
  680        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  681        '''
  682
  683        '''
  684        self.healthy = healthy if healthy is not None else False
  685        '''
  686         True if the datasource is reachable and the credentials are valid.
  687        '''
  688        self.id = id if id is not None else ''
  689        '''
  690         Unique identifier of the Resource.
  691        '''
  692        self.name = name if name is not None else ''
  693        '''
  694         Unique human-readable name of the Resource.
  695        '''
  696        self.role_arn = role_arn if role_arn is not None else ''
  697        '''
  698
  699        '''
  700        self.role_external_id = role_external_id if role_external_id is not None else ''
  701        '''
  702
  703        '''
  704        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  705        '''
  706
  707        '''
  708        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  709        '''
  710         ID of the secret store containing credentials for this resource, if any.
  711        '''
  712        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  713        '''
  714         Tags is a map of key, value pairs.
  715        '''
  716
  717    def __repr__(self):
  718        return '<sdm.AWS ' + \
  719            'access_key: ' + repr(self.access_key) + ' ' +\
  720            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  721            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  722            'healthy: ' + repr(self.healthy) + ' ' +\
  723            'id: ' + repr(self.id) + ' ' +\
  724            'name: ' + repr(self.name) + ' ' +\
  725            'role_arn: ' + repr(self.role_arn) + ' ' +\
  726            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  727            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  728            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  729            'tags: ' + repr(self.tags) + ' ' +\
  730            '>'
  731
  732    def to_dict(self):
  733        return {
  734            'access_key': self.access_key,
  735            'egress_filter': self.egress_filter,
  736            'healthcheck_region': self.healthcheck_region,
  737            'healthy': self.healthy,
  738            'id': self.id,
  739            'name': self.name,
  740            'role_arn': self.role_arn,
  741            'role_external_id': self.role_external_id,
  742            'secret_access_key': self.secret_access_key,
  743            'secret_store_id': self.secret_store_id,
  744            'tags': self.tags,
  745        }
  746
  747    @classmethod
  748    def from_dict(cls, d):
  749        return cls(
  750            access_key=d.get('access_key'),
  751            egress_filter=d.get('egress_filter'),
  752            healthcheck_region=d.get('healthcheck_region'),
  753            healthy=d.get('healthy'),
  754            id=d.get('id'),
  755            name=d.get('name'),
  756            role_arn=d.get('role_arn'),
  757            role_external_id=d.get('role_external_id'),
  758            secret_access_key=d.get('secret_access_key'),
  759            secret_store_id=d.get('secret_store_id'),
  760            tags=d.get('tags'),
  761        )
  762
  763
  764class AWSStore:
  765    '''
  766
  767    '''
  768    __slots__ = [
  769        'id',
  770        'name',
  771        'region',
  772        'tags',
  773    ]
  774
  775    def __init__(
  776        self,
  777        id=None,
  778        name=None,
  779        region=None,
  780        tags=None,
  781    ):
  782        self.id = id if id is not None else ''
  783        '''
  784         Unique identifier of the SecretStore.
  785        '''
  786        self.name = name if name is not None else ''
  787        '''
  788         Unique human-readable name of the SecretStore.
  789        '''
  790        self.region = region if region is not None else ''
  791        '''
  792
  793        '''
  794        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  795        '''
  796         Tags is a map of key, value pairs.
  797        '''
  798
  799    def __repr__(self):
  800        return '<sdm.AWSStore ' + \
  801            'id: ' + repr(self.id) + ' ' +\
  802            'name: ' + repr(self.name) + ' ' +\
  803            'region: ' + repr(self.region) + ' ' +\
  804            'tags: ' + repr(self.tags) + ' ' +\
  805            '>'
  806
  807    def to_dict(self):
  808        return {
  809            'id': self.id,
  810            'name': self.name,
  811            'region': self.region,
  812            'tags': self.tags,
  813        }
  814
  815    @classmethod
  816    def from_dict(cls, d):
  817        return cls(
  818            id=d.get('id'),
  819            name=d.get('name'),
  820            region=d.get('region'),
  821            tags=d.get('tags'),
  822        )
  823
  824
  825class AccountAttachment:
  826    '''
  827     AccountAttachments assign an account to a role.
  828    '''
  829    __slots__ = [
  830        'account_id',
  831        'id',
  832        'role_id',
  833    ]
  834
  835    def __init__(
  836        self,
  837        account_id=None,
  838        id=None,
  839        role_id=None,
  840    ):
  841        self.account_id = account_id if account_id is not None else ''
  842        '''
  843         The id of the account of this AccountAttachment.
  844        '''
  845        self.id = id if id is not None else ''
  846        '''
  847         Unique identifier of the AccountAttachment.
  848        '''
  849        self.role_id = role_id if role_id is not None else ''
  850        '''
  851         The id of the attached role of this AccountAttachment.
  852        '''
  853
  854    def __repr__(self):
  855        return '<sdm.AccountAttachment ' + \
  856            'account_id: ' + repr(self.account_id) + ' ' +\
  857            'id: ' + repr(self.id) + ' ' +\
  858            'role_id: ' + repr(self.role_id) + ' ' +\
  859            '>'
  860
  861    def to_dict(self):
  862        return {
  863            'account_id': self.account_id,
  864            'id': self.id,
  865            'role_id': self.role_id,
  866        }
  867
  868    @classmethod
  869    def from_dict(cls, d):
  870        return cls(
  871            account_id=d.get('account_id'),
  872            id=d.get('id'),
  873            role_id=d.get('role_id'),
  874        )
  875
  876
  877class AccountAttachmentCreateResponse:
  878    '''
  879     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
  880    '''
  881    __slots__ = [
  882        'account_attachment',
  883        'meta',
  884        'rate_limit',
  885    ]
  886
  887    def __init__(
  888        self,
  889        account_attachment=None,
  890        meta=None,
  891        rate_limit=None,
  892    ):
  893        self.account_attachment = account_attachment if account_attachment is not None else None
  894        '''
  895         The created AccountAttachment.
  896        '''
  897        self.meta = meta if meta is not None else None
  898        '''
  899         Reserved for future use.
  900        '''
  901        self.rate_limit = rate_limit if rate_limit is not None else None
  902        '''
  903         Rate limit information.
  904        '''
  905
  906    def __repr__(self):
  907        return '<sdm.AccountAttachmentCreateResponse ' + \
  908            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
  909            'meta: ' + repr(self.meta) + ' ' +\
  910            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
  911            '>'
  912
  913    def to_dict(self):
  914        return {
  915            'account_attachment': self.account_attachment,
  916            'meta': self.meta,
  917            'rate_limit': self.rate_limit,
  918        }
  919
  920    @classmethod
  921    def from_dict(cls, d):
  922        return cls(
  923            account_attachment=d.get('account_attachment'),
  924            meta=d.get('meta'),
  925            rate_limit=d.get('rate_limit'),
  926        )
  927
  928
  929class AccountAttachmentDeleteResponse:
  930    '''
  931     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
  932    '''
  933    __slots__ = [
  934        'meta',
  935        'rate_limit',
  936    ]
  937
  938    def __init__(
  939        self,
  940        meta=None,
  941        rate_limit=None,
  942    ):
  943        self.meta = meta if meta is not None else None
  944        '''
  945         Reserved for future use.
  946        '''
  947        self.rate_limit = rate_limit if rate_limit is not None else None
  948        '''
  949         Rate limit information.
  950        '''
  951
  952    def __repr__(self):
  953        return '<sdm.AccountAttachmentDeleteResponse ' + \
  954            'meta: ' + repr(self.meta) + ' ' +\
  955            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
  956            '>'
  957
  958    def to_dict(self):
  959        return {
  960            'meta': self.meta,
  961            'rate_limit': self.rate_limit,
  962        }
  963
  964    @classmethod
  965    def from_dict(cls, d):
  966        return cls(
  967            meta=d.get('meta'),
  968            rate_limit=d.get('rate_limit'),
  969        )
  970
  971
  972class AccountAttachmentGetResponse:
  973    '''
  974     AccountAttachmentGetResponse returns a requested AccountAttachment.
  975    '''
  976    __slots__ = [
  977        'account_attachment',
  978        'meta',
  979        'rate_limit',
  980    ]
  981
  982    def __init__(
  983        self,
  984        account_attachment=None,
  985        meta=None,
  986        rate_limit=None,
  987    ):
  988        self.account_attachment = account_attachment if account_attachment is not None else None
  989        '''
  990         The requested AccountAttachment.
  991        '''
  992        self.meta = meta if meta is not None else None
  993        '''
  994         Reserved for future use.
  995        '''
  996        self.rate_limit = rate_limit if rate_limit is not None else None
  997        '''
  998         Rate limit information.
  999        '''
 1000
 1001    def __repr__(self):
 1002        return '<sdm.AccountAttachmentGetResponse ' + \
 1003            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1004            'meta: ' + repr(self.meta) + ' ' +\
 1005            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1006            '>'
 1007
 1008    def to_dict(self):
 1009        return {
 1010            'account_attachment': self.account_attachment,
 1011            'meta': self.meta,
 1012            'rate_limit': self.rate_limit,
 1013        }
 1014
 1015    @classmethod
 1016    def from_dict(cls, d):
 1017        return cls(
 1018            account_attachment=d.get('account_attachment'),
 1019            meta=d.get('meta'),
 1020            rate_limit=d.get('rate_limit'),
 1021        )
 1022
 1023
 1024class AccountCreateResponse:
 1025    '''
 1026     AccountCreateResponse reports how the Accounts were created in the system.
 1027    '''
 1028    __slots__ = [
 1029        'account',
 1030        'meta',
 1031        'rate_limit',
 1032        'token',
 1033    ]
 1034
 1035    def __init__(
 1036        self,
 1037        account=None,
 1038        meta=None,
 1039        rate_limit=None,
 1040        token=None,
 1041    ):
 1042        self.account = account if account is not None else None
 1043        '''
 1044         The created Account.
 1045        '''
 1046        self.meta = meta if meta is not None else None
 1047        '''
 1048         Reserved for future use.
 1049        '''
 1050        self.rate_limit = rate_limit if rate_limit is not None else None
 1051        '''
 1052         Rate limit information.
 1053        '''
 1054        self.token = token if token is not None else ''
 1055        '''
 1056         The auth token generated for the Account. The Account will use this token to
 1057         authenticate with the strongDM API.
 1058        '''
 1059
 1060    def __repr__(self):
 1061        return '<sdm.AccountCreateResponse ' + \
 1062            'account: ' + repr(self.account) + ' ' +\
 1063            'meta: ' + repr(self.meta) + ' ' +\
 1064            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1065            'token: ' + repr(self.token) + ' ' +\
 1066            '>'
 1067
 1068    def to_dict(self):
 1069        return {
 1070            'account': self.account,
 1071            'meta': self.meta,
 1072            'rate_limit': self.rate_limit,
 1073            'token': self.token,
 1074        }
 1075
 1076    @classmethod
 1077    def from_dict(cls, d):
 1078        return cls(
 1079            account=d.get('account'),
 1080            meta=d.get('meta'),
 1081            rate_limit=d.get('rate_limit'),
 1082            token=d.get('token'),
 1083        )
 1084
 1085
 1086class AccountDeleteResponse:
 1087    '''
 1088     AccountDeleteResponse returns information about a Account that was deleted.
 1089    '''
 1090    __slots__ = [
 1091        'meta',
 1092        'rate_limit',
 1093    ]
 1094
 1095    def __init__(
 1096        self,
 1097        meta=None,
 1098        rate_limit=None,
 1099    ):
 1100        self.meta = meta if meta is not None else None
 1101        '''
 1102         Reserved for future use.
 1103        '''
 1104        self.rate_limit = rate_limit if rate_limit is not None else None
 1105        '''
 1106         Rate limit information.
 1107        '''
 1108
 1109    def __repr__(self):
 1110        return '<sdm.AccountDeleteResponse ' + \
 1111            'meta: ' + repr(self.meta) + ' ' +\
 1112            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1113            '>'
 1114
 1115    def to_dict(self):
 1116        return {
 1117            'meta': self.meta,
 1118            'rate_limit': self.rate_limit,
 1119        }
 1120
 1121    @classmethod
 1122    def from_dict(cls, d):
 1123        return cls(
 1124            meta=d.get('meta'),
 1125            rate_limit=d.get('rate_limit'),
 1126        )
 1127
 1128
 1129class AccountGetResponse:
 1130    '''
 1131     AccountGetResponse returns a requested Account.
 1132    '''
 1133    __slots__ = [
 1134        'account',
 1135        'meta',
 1136        'rate_limit',
 1137    ]
 1138
 1139    def __init__(
 1140        self,
 1141        account=None,
 1142        meta=None,
 1143        rate_limit=None,
 1144    ):
 1145        self.account = account if account is not None else None
 1146        '''
 1147         The requested Account.
 1148        '''
 1149        self.meta = meta if meta is not None else None
 1150        '''
 1151         Reserved for future use.
 1152        '''
 1153        self.rate_limit = rate_limit if rate_limit is not None else None
 1154        '''
 1155         Rate limit information.
 1156        '''
 1157
 1158    def __repr__(self):
 1159        return '<sdm.AccountGetResponse ' + \
 1160            'account: ' + repr(self.account) + ' ' +\
 1161            'meta: ' + repr(self.meta) + ' ' +\
 1162            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1163            '>'
 1164
 1165    def to_dict(self):
 1166        return {
 1167            'account': self.account,
 1168            'meta': self.meta,
 1169            'rate_limit': self.rate_limit,
 1170        }
 1171
 1172    @classmethod
 1173    def from_dict(cls, d):
 1174        return cls(
 1175            account=d.get('account'),
 1176            meta=d.get('meta'),
 1177            rate_limit=d.get('rate_limit'),
 1178        )
 1179
 1180
 1181class AccountGrant:
 1182    '''
 1183     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1184    '''
 1185    __slots__ = [
 1186        'account_id',
 1187        'id',
 1188        'resource_id',
 1189        'start_from',
 1190        'valid_until',
 1191    ]
 1192
 1193    def __init__(
 1194        self,
 1195        account_id=None,
 1196        id=None,
 1197        resource_id=None,
 1198        start_from=None,
 1199        valid_until=None,
 1200    ):
 1201        self.account_id = account_id if account_id is not None else ''
 1202        '''
 1203         The id of the attached role of this AccountGrant.
 1204        '''
 1205        self.id = id if id is not None else ''
 1206        '''
 1207         Unique identifier of the AccountGrant.
 1208        '''
 1209        self.resource_id = resource_id if resource_id is not None else ''
 1210        '''
 1211         The id of the composite role of this AccountGrant.
 1212        '''
 1213        self.start_from = start_from if start_from is not None else None
 1214        '''
 1215         The timestamp when the resource will be granted. Optional. Both start_at
 1216         and end_at must be defined together, or not defined at all.
 1217        '''
 1218        self.valid_until = valid_until if valid_until is not None else None
 1219        '''
 1220         The timestamp when the resource grant will expire. Optional. Both
 1221         start_at and end_at must be defined together, or not defined at all.
 1222        '''
 1223
 1224    def __repr__(self):
 1225        return '<sdm.AccountGrant ' + \
 1226            'account_id: ' + repr(self.account_id) + ' ' +\
 1227            'id: ' + repr(self.id) + ' ' +\
 1228            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1229            'start_from: ' + repr(self.start_from) + ' ' +\
 1230            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1231            '>'
 1232
 1233    def to_dict(self):
 1234        return {
 1235            'account_id': self.account_id,
 1236            'id': self.id,
 1237            'resource_id': self.resource_id,
 1238            'start_from': self.start_from,
 1239            'valid_until': self.valid_until,
 1240        }
 1241
 1242    @classmethod
 1243    def from_dict(cls, d):
 1244        return cls(
 1245            account_id=d.get('account_id'),
 1246            id=d.get('id'),
 1247            resource_id=d.get('resource_id'),
 1248            start_from=d.get('start_from'),
 1249            valid_until=d.get('valid_until'),
 1250        )
 1251
 1252
 1253class AccountGrantCreateResponse:
 1254    '''
 1255     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1256    '''
 1257    __slots__ = [
 1258        'account_grant',
 1259        'meta',
 1260        'rate_limit',
 1261    ]
 1262
 1263    def __init__(
 1264        self,
 1265        account_grant=None,
 1266        meta=None,
 1267        rate_limit=None,
 1268    ):
 1269        self.account_grant = account_grant if account_grant is not None else None
 1270        '''
 1271         The created AccountGrant.
 1272        '''
 1273        self.meta = meta if meta is not None else None
 1274        '''
 1275         Reserved for future use.
 1276        '''
 1277        self.rate_limit = rate_limit if rate_limit is not None else None
 1278        '''
 1279         Rate limit information.
 1280        '''
 1281
 1282    def __repr__(self):
 1283        return '<sdm.AccountGrantCreateResponse ' + \
 1284            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1285            'meta: ' + repr(self.meta) + ' ' +\
 1286            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1287            '>'
 1288
 1289    def to_dict(self):
 1290        return {
 1291            'account_grant': self.account_grant,
 1292            'meta': self.meta,
 1293            'rate_limit': self.rate_limit,
 1294        }
 1295
 1296    @classmethod
 1297    def from_dict(cls, d):
 1298        return cls(
 1299            account_grant=d.get('account_grant'),
 1300            meta=d.get('meta'),
 1301            rate_limit=d.get('rate_limit'),
 1302        )
 1303
 1304
 1305class AccountGrantDeleteResponse:
 1306    '''
 1307     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1308    '''
 1309    __slots__ = [
 1310        'meta',
 1311        'rate_limit',
 1312    ]
 1313
 1314    def __init__(
 1315        self,
 1316        meta=None,
 1317        rate_limit=None,
 1318    ):
 1319        self.meta = meta if meta is not None else None
 1320        '''
 1321         Reserved for future use.
 1322        '''
 1323        self.rate_limit = rate_limit if rate_limit is not None else None
 1324        '''
 1325         Rate limit information.
 1326        '''
 1327
 1328    def __repr__(self):
 1329        return '<sdm.AccountGrantDeleteResponse ' + \
 1330            'meta: ' + repr(self.meta) + ' ' +\
 1331            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1332            '>'
 1333
 1334    def to_dict(self):
 1335        return {
 1336            'meta': self.meta,
 1337            'rate_limit': self.rate_limit,
 1338        }
 1339
 1340    @classmethod
 1341    def from_dict(cls, d):
 1342        return cls(
 1343            meta=d.get('meta'),
 1344            rate_limit=d.get('rate_limit'),
 1345        )
 1346
 1347
 1348class AccountGrantGetResponse:
 1349    '''
 1350     AccountGrantGetResponse returns a requested AccountGrant.
 1351    '''
 1352    __slots__ = [
 1353        'account_grant',
 1354        'meta',
 1355        'rate_limit',
 1356    ]
 1357
 1358    def __init__(
 1359        self,
 1360        account_grant=None,
 1361        meta=None,
 1362        rate_limit=None,
 1363    ):
 1364        self.account_grant = account_grant if account_grant is not None else None
 1365        '''
 1366         The requested AccountGrant.
 1367        '''
 1368        self.meta = meta if meta is not None else None
 1369        '''
 1370         Reserved for future use.
 1371        '''
 1372        self.rate_limit = rate_limit if rate_limit is not None else None
 1373        '''
 1374         Rate limit information.
 1375        '''
 1376
 1377    def __repr__(self):
 1378        return '<sdm.AccountGrantGetResponse ' + \
 1379            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1380            'meta: ' + repr(self.meta) + ' ' +\
 1381            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1382            '>'
 1383
 1384    def to_dict(self):
 1385        return {
 1386            'account_grant': self.account_grant,
 1387            'meta': self.meta,
 1388            'rate_limit': self.rate_limit,
 1389        }
 1390
 1391    @classmethod
 1392    def from_dict(cls, d):
 1393        return cls(
 1394            account_grant=d.get('account_grant'),
 1395            meta=d.get('meta'),
 1396            rate_limit=d.get('rate_limit'),
 1397        )
 1398
 1399
 1400class AccountUpdateResponse:
 1401    '''
 1402     AccountUpdateResponse returns the fields of a Account after it has been updated by
 1403     a AccountUpdateRequest.
 1404    '''
 1405    __slots__ = [
 1406        'account',
 1407        'meta',
 1408        'rate_limit',
 1409    ]
 1410
 1411    def __init__(
 1412        self,
 1413        account=None,
 1414        meta=None,
 1415        rate_limit=None,
 1416    ):
 1417        self.account = account if account is not None else None
 1418        '''
 1419         The updated Account.
 1420        '''
 1421        self.meta = meta if meta is not None else None
 1422        '''
 1423         Reserved for future use.
 1424        '''
 1425        self.rate_limit = rate_limit if rate_limit is not None else None
 1426        '''
 1427         Rate limit information.
 1428        '''
 1429
 1430    def __repr__(self):
 1431        return '<sdm.AccountUpdateResponse ' + \
 1432            'account: ' + repr(self.account) + ' ' +\
 1433            'meta: ' + repr(self.meta) + ' ' +\
 1434            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1435            '>'
 1436
 1437    def to_dict(self):
 1438        return {
 1439            'account': self.account,
 1440            'meta': self.meta,
 1441            'rate_limit': self.rate_limit,
 1442        }
 1443
 1444    @classmethod
 1445    def from_dict(cls, d):
 1446        return cls(
 1447            account=d.get('account'),
 1448            meta=d.get('meta'),
 1449            rate_limit=d.get('rate_limit'),
 1450        )
 1451
 1452
 1453class AmazonEKS:
 1454    '''
 1455
 1456    '''
 1457    __slots__ = [
 1458        'access_key',
 1459        'certificate_authority',
 1460        'cluster_name',
 1461        'egress_filter',
 1462        'endpoint',
 1463        'healthcheck_namespace',
 1464        'healthy',
 1465        'id',
 1466        'name',
 1467        'region',
 1468        'role_arn',
 1469        'role_external_id',
 1470        'secret_access_key',
 1471        'secret_store_id',
 1472        'tags',
 1473    ]
 1474
 1475    def __init__(
 1476        self,
 1477        access_key=None,
 1478        certificate_authority=None,
 1479        cluster_name=None,
 1480        egress_filter=None,
 1481        endpoint=None,
 1482        healthcheck_namespace=None,
 1483        healthy=None,
 1484        id=None,
 1485        name=None,
 1486        region=None,
 1487        role_arn=None,
 1488        role_external_id=None,
 1489        secret_access_key=None,
 1490        secret_store_id=None,
 1491        tags=None,
 1492    ):
 1493        self.access_key = access_key if access_key is not None else ''
 1494        '''
 1495
 1496        '''
 1497        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1498        '''
 1499
 1500        '''
 1501        self.cluster_name = cluster_name if cluster_name is not None else ''
 1502        '''
 1503
 1504        '''
 1505        self.egress_filter = egress_filter if egress_filter is not None else ''
 1506        '''
 1507         A filter applied to the routing logic to pin datasource to nodes.
 1508        '''
 1509        self.endpoint = endpoint if endpoint is not None else ''
 1510        '''
 1511
 1512        '''
 1513        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1514        '''
 1515         The path used to check the health of your connection.  Defaults to `default`.
 1516        '''
 1517        self.healthy = healthy if healthy is not None else False
 1518        '''
 1519         True if the datasource is reachable and the credentials are valid.
 1520        '''
 1521        self.id = id if id is not None else ''
 1522        '''
 1523         Unique identifier of the Resource.
 1524        '''
 1525        self.name = name if name is not None else ''
 1526        '''
 1527         Unique human-readable name of the Resource.
 1528        '''
 1529        self.region = region if region is not None else ''
 1530        '''
 1531
 1532        '''
 1533        self.role_arn = role_arn if role_arn is not None else ''
 1534        '''
 1535
 1536        '''
 1537        self.role_external_id = role_external_id if role_external_id is not None else ''
 1538        '''
 1539
 1540        '''
 1541        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1542        '''
 1543
 1544        '''
 1545        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1546        '''
 1547         ID of the secret store containing credentials for this resource, if any.
 1548        '''
 1549        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1550        '''
 1551         Tags is a map of key, value pairs.
 1552        '''
 1553
 1554    def __repr__(self):
 1555        return '<sdm.AmazonEKS ' + \
 1556            'access_key: ' + repr(self.access_key) + ' ' +\
 1557            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1558            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1559            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1560            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1561            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1562            'healthy: ' + repr(self.healthy) + ' ' +\
 1563            'id: ' + repr(self.id) + ' ' +\
 1564            'name: ' + repr(self.name) + ' ' +\
 1565            'region: ' + repr(self.region) + ' ' +\
 1566            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1567            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1568            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1569            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1570            'tags: ' + repr(self.tags) + ' ' +\
 1571            '>'
 1572
 1573    def to_dict(self):
 1574        return {
 1575            'access_key': self.access_key,
 1576            'certificate_authority': self.certificate_authority,
 1577            'cluster_name': self.cluster_name,
 1578            'egress_filter': self.egress_filter,
 1579            'endpoint': self.endpoint,
 1580            'healthcheck_namespace': self.healthcheck_namespace,
 1581            'healthy': self.healthy,
 1582            'id': self.id,
 1583            'name': self.name,
 1584            'region': self.region,
 1585            'role_arn': self.role_arn,
 1586            'role_external_id': self.role_external_id,
 1587            'secret_access_key': self.secret_access_key,
 1588            'secret_store_id': self.secret_store_id,
 1589            'tags': self.tags,
 1590        }
 1591
 1592    @classmethod
 1593    def from_dict(cls, d):
 1594        return cls(
 1595            access_key=d.get('access_key'),
 1596            certificate_authority=d.get('certificate_authority'),
 1597            cluster_name=d.get('cluster_name'),
 1598            egress_filter=d.get('egress_filter'),
 1599            endpoint=d.get('endpoint'),
 1600            healthcheck_namespace=d.get('healthcheck_namespace'),
 1601            healthy=d.get('healthy'),
 1602            id=d.get('id'),
 1603            name=d.get('name'),
 1604            region=d.get('region'),
 1605            role_arn=d.get('role_arn'),
 1606            role_external_id=d.get('role_external_id'),
 1607            secret_access_key=d.get('secret_access_key'),
 1608            secret_store_id=d.get('secret_store_id'),
 1609            tags=d.get('tags'),
 1610        )
 1611
 1612
 1613class AmazonEKSUserImpersonation:
 1614    '''
 1615
 1616    '''
 1617    __slots__ = [
 1618        'access_key',
 1619        'certificate_authority',
 1620        'cluster_name',
 1621        'egress_filter',
 1622        'endpoint',
 1623        'healthcheck_namespace',
 1624        'healthy',
 1625        'id',
 1626        'name',
 1627        'region',
 1628        'role_arn',
 1629        'role_external_id',
 1630        'secret_access_key',
 1631        'secret_store_id',
 1632        'tags',
 1633    ]
 1634
 1635    def __init__(
 1636        self,
 1637        access_key=None,
 1638        certificate_authority=None,
 1639        cluster_name=None,
 1640        egress_filter=None,
 1641        endpoint=None,
 1642        healthcheck_namespace=None,
 1643        healthy=None,
 1644        id=None,
 1645        name=None,
 1646        region=None,
 1647        role_arn=None,
 1648        role_external_id=None,
 1649        secret_access_key=None,
 1650        secret_store_id=None,
 1651        tags=None,
 1652    ):
 1653        self.access_key = access_key if access_key is not None else ''
 1654        '''
 1655
 1656        '''
 1657        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1658        '''
 1659
 1660        '''
 1661        self.cluster_name = cluster_name if cluster_name is not None else ''
 1662        '''
 1663
 1664        '''
 1665        self.egress_filter = egress_filter if egress_filter is not None else ''
 1666        '''
 1667         A filter applied to the routing logic to pin datasource to nodes.
 1668        '''
 1669        self.endpoint = endpoint if endpoint is not None else ''
 1670        '''
 1671
 1672        '''
 1673        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1674        '''
 1675         The path used to check the health of your connection.  Defaults to `default`.
 1676        '''
 1677        self.healthy = healthy if healthy is not None else False
 1678        '''
 1679         True if the datasource is reachable and the credentials are valid.
 1680        '''
 1681        self.id = id if id is not None else ''
 1682        '''
 1683         Unique identifier of the Resource.
 1684        '''
 1685        self.name = name if name is not None else ''
 1686        '''
 1687         Unique human-readable name of the Resource.
 1688        '''
 1689        self.region = region if region is not None else ''
 1690        '''
 1691
 1692        '''
 1693        self.role_arn = role_arn if role_arn is not None else ''
 1694        '''
 1695
 1696        '''
 1697        self.role_external_id = role_external_id if role_external_id is not None else ''
 1698        '''
 1699
 1700        '''
 1701        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1702        '''
 1703
 1704        '''
 1705        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1706        '''
 1707         ID of the secret store containing credentials for this resource, if any.
 1708        '''
 1709        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1710        '''
 1711         Tags is a map of key, value pairs.
 1712        '''
 1713
 1714    def __repr__(self):
 1715        return '<sdm.AmazonEKSUserImpersonation ' + \
 1716            'access_key: ' + repr(self.access_key) + ' ' +\
 1717            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1718            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1719            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1720            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1721            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1722            'healthy: ' + repr(self.healthy) + ' ' +\
 1723            'id: ' + repr(self.id) + ' ' +\
 1724            'name: ' + repr(self.name) + ' ' +\
 1725            'region: ' + repr(self.region) + ' ' +\
 1726            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1727            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1728            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1730            'tags: ' + repr(self.tags) + ' ' +\
 1731            '>'
 1732
 1733    def to_dict(self):
 1734        return {
 1735            'access_key': self.access_key,
 1736            'certificate_authority': self.certificate_authority,
 1737            'cluster_name': self.cluster_name,
 1738            'egress_filter': self.egress_filter,
 1739            'endpoint': self.endpoint,
 1740            'healthcheck_namespace': self.healthcheck_namespace,
 1741            'healthy': self.healthy,
 1742            'id': self.id,
 1743            'name': self.name,
 1744            'region': self.region,
 1745            'role_arn': self.role_arn,
 1746            'role_external_id': self.role_external_id,
 1747            'secret_access_key': self.secret_access_key,
 1748            'secret_store_id': self.secret_store_id,
 1749            'tags': self.tags,
 1750        }
 1751
 1752    @classmethod
 1753    def from_dict(cls, d):
 1754        return cls(
 1755            access_key=d.get('access_key'),
 1756            certificate_authority=d.get('certificate_authority'),
 1757            cluster_name=d.get('cluster_name'),
 1758            egress_filter=d.get('egress_filter'),
 1759            endpoint=d.get('endpoint'),
 1760            healthcheck_namespace=d.get('healthcheck_namespace'),
 1761            healthy=d.get('healthy'),
 1762            id=d.get('id'),
 1763            name=d.get('name'),
 1764            region=d.get('region'),
 1765            role_arn=d.get('role_arn'),
 1766            role_external_id=d.get('role_external_id'),
 1767            secret_access_key=d.get('secret_access_key'),
 1768            secret_store_id=d.get('secret_store_id'),
 1769            tags=d.get('tags'),
 1770        )
 1771
 1772
 1773class AmazonES:
 1774    '''
 1775
 1776    '''
 1777    __slots__ = [
 1778        'access_key',
 1779        'egress_filter',
 1780        'endpoint',
 1781        'healthy',
 1782        'id',
 1783        'name',
 1784        'port_override',
 1785        'region',
 1786        'role_arn',
 1787        'role_external_id',
 1788        'secret_access_key',
 1789        'secret_store_id',
 1790        'tags',
 1791    ]
 1792
 1793    def __init__(
 1794        self,
 1795        access_key=None,
 1796        egress_filter=None,
 1797        endpoint=None,
 1798        healthy=None,
 1799        id=None,
 1800        name=None,
 1801        port_override=None,
 1802        region=None,
 1803        role_arn=None,
 1804        role_external_id=None,
 1805        secret_access_key=None,
 1806        secret_store_id=None,
 1807        tags=None,
 1808    ):
 1809        self.access_key = access_key if access_key is not None else ''
 1810        '''
 1811
 1812        '''
 1813        self.egress_filter = egress_filter if egress_filter is not None else ''
 1814        '''
 1815         A filter applied to the routing logic to pin datasource to nodes.
 1816        '''
 1817        self.endpoint = endpoint if endpoint is not None else ''
 1818        '''
 1819
 1820        '''
 1821        self.healthy = healthy if healthy is not None else False
 1822        '''
 1823         True if the datasource is reachable and the credentials are valid.
 1824        '''
 1825        self.id = id if id is not None else ''
 1826        '''
 1827         Unique identifier of the Resource.
 1828        '''
 1829        self.name = name if name is not None else ''
 1830        '''
 1831         Unique human-readable name of the Resource.
 1832        '''
 1833        self.port_override = port_override if port_override is not None else 0
 1834        '''
 1835
 1836        '''
 1837        self.region = region if region is not None else ''
 1838        '''
 1839
 1840        '''
 1841        self.role_arn = role_arn if role_arn is not None else ''
 1842        '''
 1843
 1844        '''
 1845        self.role_external_id = role_external_id if role_external_id is not None else ''
 1846        '''
 1847
 1848        '''
 1849        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1850        '''
 1851
 1852        '''
 1853        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1854        '''
 1855         ID of the secret store containing credentials for this resource, if any.
 1856        '''
 1857        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1858        '''
 1859         Tags is a map of key, value pairs.
 1860        '''
 1861
 1862    def __repr__(self):
 1863        return '<sdm.AmazonES ' + \
 1864            'access_key: ' + repr(self.access_key) + ' ' +\
 1865            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1866            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1867            'healthy: ' + repr(self.healthy) + ' ' +\
 1868            'id: ' + repr(self.id) + ' ' +\
 1869            'name: ' + repr(self.name) + ' ' +\
 1870            'port_override: ' + repr(self.port_override) + ' ' +\
 1871            'region: ' + repr(self.region) + ' ' +\
 1872            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1873            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1874            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1875            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1876            'tags: ' + repr(self.tags) + ' ' +\
 1877            '>'
 1878
 1879    def to_dict(self):
 1880        return {
 1881            'access_key': self.access_key,
 1882            'egress_filter': self.egress_filter,
 1883            'endpoint': self.endpoint,
 1884            'healthy': self.healthy,
 1885            'id': self.id,
 1886            'name': self.name,
 1887            'port_override': self.port_override,
 1888            'region': self.region,
 1889            'role_arn': self.role_arn,
 1890            'role_external_id': self.role_external_id,
 1891            'secret_access_key': self.secret_access_key,
 1892            'secret_store_id': self.secret_store_id,
 1893            'tags': self.tags,
 1894        }
 1895
 1896    @classmethod
 1897    def from_dict(cls, d):
 1898        return cls(
 1899            access_key=d.get('access_key'),
 1900            egress_filter=d.get('egress_filter'),
 1901            endpoint=d.get('endpoint'),
 1902            healthy=d.get('healthy'),
 1903            id=d.get('id'),
 1904            name=d.get('name'),
 1905            port_override=d.get('port_override'),
 1906            region=d.get('region'),
 1907            role_arn=d.get('role_arn'),
 1908            role_external_id=d.get('role_external_id'),
 1909            secret_access_key=d.get('secret_access_key'),
 1910            secret_store_id=d.get('secret_store_id'),
 1911            tags=d.get('tags'),
 1912        )
 1913
 1914
 1915class AmazonMQAMQP091:
 1916    '''
 1917
 1918    '''
 1919    __slots__ = [
 1920        'egress_filter',
 1921        'healthy',
 1922        'hostname',
 1923        'id',
 1924        'name',
 1925        'password',
 1926        'port',
 1927        'port_override',
 1928        'secret_store_id',
 1929        'tags',
 1930        'tls_required',
 1931        'username',
 1932    ]
 1933
 1934    def __init__(
 1935        self,
 1936        egress_filter=None,
 1937        healthy=None,
 1938        hostname=None,
 1939        id=None,
 1940        name=None,
 1941        password=None,
 1942        port=None,
 1943        port_override=None,
 1944        secret_store_id=None,
 1945        tags=None,
 1946        tls_required=None,
 1947        username=None,
 1948    ):
 1949        self.egress_filter = egress_filter if egress_filter is not None else ''
 1950        '''
 1951         A filter applied to the routing logic to pin datasource to nodes.
 1952        '''
 1953        self.healthy = healthy if healthy is not None else False
 1954        '''
 1955         True if the datasource is reachable and the credentials are valid.
 1956        '''
 1957        self.hostname = hostname if hostname is not None else ''
 1958        '''
 1959
 1960        '''
 1961        self.id = id if id is not None else ''
 1962        '''
 1963         Unique identifier of the Resource.
 1964        '''
 1965        self.name = name if name is not None else ''
 1966        '''
 1967         Unique human-readable name of the Resource.
 1968        '''
 1969        self.password = password if password is not None else ''
 1970        '''
 1971
 1972        '''
 1973        self.port = port if port is not None else 0
 1974        '''
 1975
 1976        '''
 1977        self.port_override = port_override if port_override is not None else 0
 1978        '''
 1979
 1980        '''
 1981        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1982        '''
 1983         ID of the secret store containing credentials for this resource, if any.
 1984        '''
 1985        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1986        '''
 1987         Tags is a map of key, value pairs.
 1988        '''
 1989        self.tls_required = tls_required if tls_required is not None else False
 1990        '''
 1991
 1992        '''
 1993        self.username = username if username is not None else ''
 1994        '''
 1995
 1996        '''
 1997
 1998    def __repr__(self):
 1999        return '<sdm.AmazonMQAMQP091 ' + \
 2000            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2001            'healthy: ' + repr(self.healthy) + ' ' +\
 2002            'hostname: ' + repr(self.hostname) + ' ' +\
 2003            'id: ' + repr(self.id) + ' ' +\
 2004            'name: ' + repr(self.name) + ' ' +\
 2005            'password: ' + repr(self.password) + ' ' +\
 2006            'port: ' + repr(self.port) + ' ' +\
 2007            'port_override: ' + repr(self.port_override) + ' ' +\
 2008            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2009            'tags: ' + repr(self.tags) + ' ' +\
 2010            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2011            'username: ' + repr(self.username) + ' ' +\
 2012            '>'
 2013
 2014    def to_dict(self):
 2015        return {
 2016            'egress_filter': self.egress_filter,
 2017            'healthy': self.healthy,
 2018            'hostname': self.hostname,
 2019            'id': self.id,
 2020            'name': self.name,
 2021            'password': self.password,
 2022            'port': self.port,
 2023            'port_override': self.port_override,
 2024            'secret_store_id': self.secret_store_id,
 2025            'tags': self.tags,
 2026            'tls_required': self.tls_required,
 2027            'username': self.username,
 2028        }
 2029
 2030    @classmethod
 2031    def from_dict(cls, d):
 2032        return cls(
 2033            egress_filter=d.get('egress_filter'),
 2034            healthy=d.get('healthy'),
 2035            hostname=d.get('hostname'),
 2036            id=d.get('id'),
 2037            name=d.get('name'),
 2038            password=d.get('password'),
 2039            port=d.get('port'),
 2040            port_override=d.get('port_override'),
 2041            secret_store_id=d.get('secret_store_id'),
 2042            tags=d.get('tags'),
 2043            tls_required=d.get('tls_required'),
 2044            username=d.get('username'),
 2045        )
 2046
 2047
 2048class Athena:
 2049    '''
 2050
 2051    '''
 2052    __slots__ = [
 2053        'access_key',
 2054        'egress_filter',
 2055        'healthy',
 2056        'id',
 2057        'name',
 2058        'output',
 2059        'port_override',
 2060        'region',
 2061        'role_arn',
 2062        'role_external_id',
 2063        'secret_access_key',
 2064        'secret_store_id',
 2065        'tags',
 2066    ]
 2067
 2068    def __init__(
 2069        self,
 2070        access_key=None,
 2071        egress_filter=None,
 2072        healthy=None,
 2073        id=None,
 2074        name=None,
 2075        output=None,
 2076        port_override=None,
 2077        region=None,
 2078        role_arn=None,
 2079        role_external_id=None,
 2080        secret_access_key=None,
 2081        secret_store_id=None,
 2082        tags=None,
 2083    ):
 2084        self.access_key = access_key if access_key is not None else ''
 2085        '''
 2086
 2087        '''
 2088        self.egress_filter = egress_filter if egress_filter is not None else ''
 2089        '''
 2090         A filter applied to the routing logic to pin datasource to nodes.
 2091        '''
 2092        self.healthy = healthy if healthy is not None else False
 2093        '''
 2094         True if the datasource is reachable and the credentials are valid.
 2095        '''
 2096        self.id = id if id is not None else ''
 2097        '''
 2098         Unique identifier of the Resource.
 2099        '''
 2100        self.name = name if name is not None else ''
 2101        '''
 2102         Unique human-readable name of the Resource.
 2103        '''
 2104        self.output = output if output is not None else ''
 2105        '''
 2106
 2107        '''
 2108        self.port_override = port_override if port_override is not None else 0
 2109        '''
 2110
 2111        '''
 2112        self.region = region if region is not None else ''
 2113        '''
 2114
 2115        '''
 2116        self.role_arn = role_arn if role_arn is not None else ''
 2117        '''
 2118
 2119        '''
 2120        self.role_external_id = role_external_id if role_external_id is not None else ''
 2121        '''
 2122
 2123        '''
 2124        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2125        '''
 2126
 2127        '''
 2128        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2129        '''
 2130         ID of the secret store containing credentials for this resource, if any.
 2131        '''
 2132        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2133        '''
 2134         Tags is a map of key, value pairs.
 2135        '''
 2136
 2137    def __repr__(self):
 2138        return '<sdm.Athena ' + \
 2139            'access_key: ' + repr(self.access_key) + ' ' +\
 2140            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2141            'healthy: ' + repr(self.healthy) + ' ' +\
 2142            'id: ' + repr(self.id) + ' ' +\
 2143            'name: ' + repr(self.name) + ' ' +\
 2144            'output: ' + repr(self.output) + ' ' +\
 2145            'port_override: ' + repr(self.port_override) + ' ' +\
 2146            'region: ' + repr(self.region) + ' ' +\
 2147            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2148            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2149            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2150            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2151            'tags: ' + repr(self.tags) + ' ' +\
 2152            '>'
 2153
 2154    def to_dict(self):
 2155        return {
 2156            'access_key': self.access_key,
 2157            'egress_filter': self.egress_filter,
 2158            'healthy': self.healthy,
 2159            'id': self.id,
 2160            'name': self.name,
 2161            'output': self.output,
 2162            'port_override': self.port_override,
 2163            'region': self.region,
 2164            'role_arn': self.role_arn,
 2165            'role_external_id': self.role_external_id,
 2166            'secret_access_key': self.secret_access_key,
 2167            'secret_store_id': self.secret_store_id,
 2168            'tags': self.tags,
 2169        }
 2170
 2171    @classmethod
 2172    def from_dict(cls, d):
 2173        return cls(
 2174            access_key=d.get('access_key'),
 2175            egress_filter=d.get('egress_filter'),
 2176            healthy=d.get('healthy'),
 2177            id=d.get('id'),
 2178            name=d.get('name'),
 2179            output=d.get('output'),
 2180            port_override=d.get('port_override'),
 2181            region=d.get('region'),
 2182            role_arn=d.get('role_arn'),
 2183            role_external_id=d.get('role_external_id'),
 2184            secret_access_key=d.get('secret_access_key'),
 2185            secret_store_id=d.get('secret_store_id'),
 2186            tags=d.get('tags'),
 2187        )
 2188
 2189
 2190class AuroraMysql:
 2191    '''
 2192
 2193    '''
 2194    __slots__ = [
 2195        'database',
 2196        'egress_filter',
 2197        'healthy',
 2198        'hostname',
 2199        'id',
 2200        'name',
 2201        'password',
 2202        'port',
 2203        'port_override',
 2204        'secret_store_id',
 2205        'tags',
 2206        'username',
 2207    ]
 2208
 2209    def __init__(
 2210        self,
 2211        database=None,
 2212        egress_filter=None,
 2213        healthy=None,
 2214        hostname=None,
 2215        id=None,
 2216        name=None,
 2217        password=None,
 2218        port=None,
 2219        port_override=None,
 2220        secret_store_id=None,
 2221        tags=None,
 2222        username=None,
 2223    ):
 2224        self.database = database if database is not None else ''
 2225        '''
 2226
 2227        '''
 2228        self.egress_filter = egress_filter if egress_filter is not None else ''
 2229        '''
 2230         A filter applied to the routing logic to pin datasource to nodes.
 2231        '''
 2232        self.healthy = healthy if healthy is not None else False
 2233        '''
 2234         True if the datasource is reachable and the credentials are valid.
 2235        '''
 2236        self.hostname = hostname if hostname is not None else ''
 2237        '''
 2238
 2239        '''
 2240        self.id = id if id is not None else ''
 2241        '''
 2242         Unique identifier of the Resource.
 2243        '''
 2244        self.name = name if name is not None else ''
 2245        '''
 2246         Unique human-readable name of the Resource.
 2247        '''
 2248        self.password = password if password is not None else ''
 2249        '''
 2250
 2251        '''
 2252        self.port = port if port is not None else 0
 2253        '''
 2254
 2255        '''
 2256        self.port_override = port_override if port_override is not None else 0
 2257        '''
 2258
 2259        '''
 2260        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2261        '''
 2262         ID of the secret store containing credentials for this resource, if any.
 2263        '''
 2264        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2265        '''
 2266         Tags is a map of key, value pairs.
 2267        '''
 2268        self.username = username if username is not None else ''
 2269        '''
 2270
 2271        '''
 2272
 2273    def __repr__(self):
 2274        return '<sdm.AuroraMysql ' + \
 2275            'database: ' + repr(self.database) + ' ' +\
 2276            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2277            'healthy: ' + repr(self.healthy) + ' ' +\
 2278            'hostname: ' + repr(self.hostname) + ' ' +\
 2279            'id: ' + repr(self.id) + ' ' +\
 2280            'name: ' + repr(self.name) + ' ' +\
 2281            'password: ' + repr(self.password) + ' ' +\
 2282            'port: ' + repr(self.port) + ' ' +\
 2283            'port_override: ' + repr(self.port_override) + ' ' +\
 2284            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2285            'tags: ' + repr(self.tags) + ' ' +\
 2286            'username: ' + repr(self.username) + ' ' +\
 2287            '>'
 2288
 2289    def to_dict(self):
 2290        return {
 2291            'database': self.database,
 2292            'egress_filter': self.egress_filter,
 2293            'healthy': self.healthy,
 2294            'hostname': self.hostname,
 2295            'id': self.id,
 2296            'name': self.name,
 2297            'password': self.password,
 2298            'port': self.port,
 2299            'port_override': self.port_override,
 2300            'secret_store_id': self.secret_store_id,
 2301            'tags': self.tags,
 2302            'username': self.username,
 2303        }
 2304
 2305    @classmethod
 2306    def from_dict(cls, d):
 2307        return cls(
 2308            database=d.get('database'),
 2309            egress_filter=d.get('egress_filter'),
 2310            healthy=d.get('healthy'),
 2311            hostname=d.get('hostname'),
 2312            id=d.get('id'),
 2313            name=d.get('name'),
 2314            password=d.get('password'),
 2315            port=d.get('port'),
 2316            port_override=d.get('port_override'),
 2317            secret_store_id=d.get('secret_store_id'),
 2318            tags=d.get('tags'),
 2319            username=d.get('username'),
 2320        )
 2321
 2322
 2323class AuroraPostgres:
 2324    '''
 2325
 2326    '''
 2327    __slots__ = [
 2328        'database',
 2329        'egress_filter',
 2330        'healthy',
 2331        'hostname',
 2332        'id',
 2333        'name',
 2334        'override_database',
 2335        'password',
 2336        'port',
 2337        'port_override',
 2338        'secret_store_id',
 2339        'tags',
 2340        'username',
 2341    ]
 2342
 2343    def __init__(
 2344        self,
 2345        database=None,
 2346        egress_filter=None,
 2347        healthy=None,
 2348        hostname=None,
 2349        id=None,
 2350        name=None,
 2351        override_database=None,
 2352        password=None,
 2353        port=None,
 2354        port_override=None,
 2355        secret_store_id=None,
 2356        tags=None,
 2357        username=None,
 2358    ):
 2359        self.database = database if database is not None else ''
 2360        '''
 2361
 2362        '''
 2363        self.egress_filter = egress_filter if egress_filter is not None else ''
 2364        '''
 2365         A filter applied to the routing logic to pin datasource to nodes.
 2366        '''
 2367        self.healthy = healthy if healthy is not None else False
 2368        '''
 2369         True if the datasource is reachable and the credentials are valid.
 2370        '''
 2371        self.hostname = hostname if hostname is not None else ''
 2372        '''
 2373
 2374        '''
 2375        self.id = id if id is not None else ''
 2376        '''
 2377         Unique identifier of the Resource.
 2378        '''
 2379        self.name = name if name is not None else ''
 2380        '''
 2381         Unique human-readable name of the Resource.
 2382        '''
 2383        self.override_database = override_database if override_database is not None else False
 2384        '''
 2385
 2386        '''
 2387        self.password = password if password is not None else ''
 2388        '''
 2389
 2390        '''
 2391        self.port = port if port is not None else 0
 2392        '''
 2393
 2394        '''
 2395        self.port_override = port_override if port_override is not None else 0
 2396        '''
 2397
 2398        '''
 2399        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2400        '''
 2401         ID of the secret store containing credentials for this resource, if any.
 2402        '''
 2403        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2404        '''
 2405         Tags is a map of key, value pairs.
 2406        '''
 2407        self.username = username if username is not None else ''
 2408        '''
 2409
 2410        '''
 2411
 2412    def __repr__(self):
 2413        return '<sdm.AuroraPostgres ' + \
 2414            'database: ' + repr(self.database) + ' ' +\
 2415            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2416            'healthy: ' + repr(self.healthy) + ' ' +\
 2417            'hostname: ' + repr(self.hostname) + ' ' +\
 2418            'id: ' + repr(self.id) + ' ' +\
 2419            'name: ' + repr(self.name) + ' ' +\
 2420            'override_database: ' + repr(self.override_database) + ' ' +\
 2421            'password: ' + repr(self.password) + ' ' +\
 2422            'port: ' + repr(self.port) + ' ' +\
 2423            'port_override: ' + repr(self.port_override) + ' ' +\
 2424            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2425            'tags: ' + repr(self.tags) + ' ' +\
 2426            'username: ' + repr(self.username) + ' ' +\
 2427            '>'
 2428
 2429    def to_dict(self):
 2430        return {
 2431            'database': self.database,
 2432            'egress_filter': self.egress_filter,
 2433            'healthy': self.healthy,
 2434            'hostname': self.hostname,
 2435            'id': self.id,
 2436            'name': self.name,
 2437            'override_database': self.override_database,
 2438            'password': self.password,
 2439            'port': self.port,
 2440            'port_override': self.port_override,
 2441            'secret_store_id': self.secret_store_id,
 2442            'tags': self.tags,
 2443            'username': self.username,
 2444        }
 2445
 2446    @classmethod
 2447    def from_dict(cls, d):
 2448        return cls(
 2449            database=d.get('database'),
 2450            egress_filter=d.get('egress_filter'),
 2451            healthy=d.get('healthy'),
 2452            hostname=d.get('hostname'),
 2453            id=d.get('id'),
 2454            name=d.get('name'),
 2455            override_database=d.get('override_database'),
 2456            password=d.get('password'),
 2457            port=d.get('port'),
 2458            port_override=d.get('port_override'),
 2459            secret_store_id=d.get('secret_store_id'),
 2460            tags=d.get('tags'),
 2461            username=d.get('username'),
 2462        )
 2463
 2464
 2465class Azure:
 2466    '''
 2467
 2468    '''
 2469    __slots__ = [
 2470        'app_id',
 2471        'egress_filter',
 2472        'healthy',
 2473        'id',
 2474        'name',
 2475        'password',
 2476        'secret_store_id',
 2477        'tags',
 2478        'tenant_id',
 2479    ]
 2480
 2481    def __init__(
 2482        self,
 2483        app_id=None,
 2484        egress_filter=None,
 2485        healthy=None,
 2486        id=None,
 2487        name=None,
 2488        password=None,
 2489        secret_store_id=None,
 2490        tags=None,
 2491        tenant_id=None,
 2492    ):
 2493        self.app_id = app_id if app_id is not None else ''
 2494        '''
 2495
 2496        '''
 2497        self.egress_filter = egress_filter if egress_filter is not None else ''
 2498        '''
 2499         A filter applied to the routing logic to pin datasource to nodes.
 2500        '''
 2501        self.healthy = healthy if healthy is not None else False
 2502        '''
 2503         True if the datasource is reachable and the credentials are valid.
 2504        '''
 2505        self.id = id if id is not None else ''
 2506        '''
 2507         Unique identifier of the Resource.
 2508        '''
 2509        self.name = name if name is not None else ''
 2510        '''
 2511         Unique human-readable name of the Resource.
 2512        '''
 2513        self.password = password if password is not None else ''
 2514        '''
 2515
 2516        '''
 2517        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2518        '''
 2519         ID of the secret store containing credentials for this resource, if any.
 2520        '''
 2521        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2522        '''
 2523         Tags is a map of key, value pairs.
 2524        '''
 2525        self.tenant_id = tenant_id if tenant_id is not None else ''
 2526        '''
 2527
 2528        '''
 2529
 2530    def __repr__(self):
 2531        return '<sdm.Azure ' + \
 2532            'app_id: ' + repr(self.app_id) + ' ' +\
 2533            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2534            'healthy: ' + repr(self.healthy) + ' ' +\
 2535            'id: ' + repr(self.id) + ' ' +\
 2536            'name: ' + repr(self.name) + ' ' +\
 2537            'password: ' + repr(self.password) + ' ' +\
 2538            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2539            'tags: ' + repr(self.tags) + ' ' +\
 2540            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2541            '>'
 2542
 2543    def to_dict(self):
 2544        return {
 2545            'app_id': self.app_id,
 2546            'egress_filter': self.egress_filter,
 2547            'healthy': self.healthy,
 2548            'id': self.id,
 2549            'name': self.name,
 2550            'password': self.password,
 2551            'secret_store_id': self.secret_store_id,
 2552            'tags': self.tags,
 2553            'tenant_id': self.tenant_id,
 2554        }
 2555
 2556    @classmethod
 2557    def from_dict(cls, d):
 2558        return cls(
 2559            app_id=d.get('app_id'),
 2560            egress_filter=d.get('egress_filter'),
 2561            healthy=d.get('healthy'),
 2562            id=d.get('id'),
 2563            name=d.get('name'),
 2564            password=d.get('password'),
 2565            secret_store_id=d.get('secret_store_id'),
 2566            tags=d.get('tags'),
 2567            tenant_id=d.get('tenant_id'),
 2568        )
 2569
 2570
 2571class AzureCertificate:
 2572    '''
 2573
 2574    '''
 2575    __slots__ = [
 2576        'app_id',
 2577        'client_certificate',
 2578        'egress_filter',
 2579        'healthy',
 2580        'id',
 2581        'name',
 2582        'secret_store_id',
 2583        'tags',
 2584        'tenant_id',
 2585    ]
 2586
 2587    def __init__(
 2588        self,
 2589        app_id=None,
 2590        client_certificate=None,
 2591        egress_filter=None,
 2592        healthy=None,
 2593        id=None,
 2594        name=None,
 2595        secret_store_id=None,
 2596        tags=None,
 2597        tenant_id=None,
 2598    ):
 2599        self.app_id = app_id if app_id is not None else ''
 2600        '''
 2601
 2602        '''
 2603        self.client_certificate = client_certificate if client_certificate is not None else ''
 2604        '''
 2605
 2606        '''
 2607        self.egress_filter = egress_filter if egress_filter is not None else ''
 2608        '''
 2609         A filter applied to the routing logic to pin datasource to nodes.
 2610        '''
 2611        self.healthy = healthy if healthy is not None else False
 2612        '''
 2613         True if the datasource is reachable and the credentials are valid.
 2614        '''
 2615        self.id = id if id is not None else ''
 2616        '''
 2617         Unique identifier of the Resource.
 2618        '''
 2619        self.name = name if name is not None else ''
 2620        '''
 2621         Unique human-readable name of the Resource.
 2622        '''
 2623        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2624        '''
 2625         ID of the secret store containing credentials for this resource, if any.
 2626        '''
 2627        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2628        '''
 2629         Tags is a map of key, value pairs.
 2630        '''
 2631        self.tenant_id = tenant_id if tenant_id is not None else ''
 2632        '''
 2633
 2634        '''
 2635
 2636    def __repr__(self):
 2637        return '<sdm.AzureCertificate ' + \
 2638            'app_id: ' + repr(self.app_id) + ' ' +\
 2639            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2640            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2641            'healthy: ' + repr(self.healthy) + ' ' +\
 2642            'id: ' + repr(self.id) + ' ' +\
 2643            'name: ' + repr(self.name) + ' ' +\
 2644            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2645            'tags: ' + repr(self.tags) + ' ' +\
 2646            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2647            '>'
 2648
 2649    def to_dict(self):
 2650        return {
 2651            'app_id': self.app_id,
 2652            'client_certificate': self.client_certificate,
 2653            'egress_filter': self.egress_filter,
 2654            'healthy': self.healthy,
 2655            'id': self.id,
 2656            'name': self.name,
 2657            'secret_store_id': self.secret_store_id,
 2658            'tags': self.tags,
 2659            'tenant_id': self.tenant_id,
 2660        }
 2661
 2662    @classmethod
 2663    def from_dict(cls, d):
 2664        return cls(
 2665            app_id=d.get('app_id'),
 2666            client_certificate=d.get('client_certificate'),
 2667            egress_filter=d.get('egress_filter'),
 2668            healthy=d.get('healthy'),
 2669            id=d.get('id'),
 2670            name=d.get('name'),
 2671            secret_store_id=d.get('secret_store_id'),
 2672            tags=d.get('tags'),
 2673            tenant_id=d.get('tenant_id'),
 2674        )
 2675
 2676
 2677class AzurePostgres:
 2678    '''
 2679
 2680    '''
 2681    __slots__ = [
 2682        'database',
 2683        'egress_filter',
 2684        'healthy',
 2685        'hostname',
 2686        'id',
 2687        'name',
 2688        'override_database',
 2689        'password',
 2690        'port',
 2691        'port_override',
 2692        'secret_store_id',
 2693        'tags',
 2694        'username',
 2695    ]
 2696
 2697    def __init__(
 2698        self,
 2699        database=None,
 2700        egress_filter=None,
 2701        healthy=None,
 2702        hostname=None,
 2703        id=None,
 2704        name=None,
 2705        override_database=None,
 2706        password=None,
 2707        port=None,
 2708        port_override=None,
 2709        secret_store_id=None,
 2710        tags=None,
 2711        username=None,
 2712    ):
 2713        self.database = database if database is not None else ''
 2714        '''
 2715
 2716        '''
 2717        self.egress_filter = egress_filter if egress_filter is not None else ''
 2718        '''
 2719         A filter applied to the routing logic to pin datasource to nodes.
 2720        '''
 2721        self.healthy = healthy if healthy is not None else False
 2722        '''
 2723         True if the datasource is reachable and the credentials are valid.
 2724        '''
 2725        self.hostname = hostname if hostname is not None else ''
 2726        '''
 2727
 2728        '''
 2729        self.id = id if id is not None else ''
 2730        '''
 2731         Unique identifier of the Resource.
 2732        '''
 2733        self.name = name if name is not None else ''
 2734        '''
 2735         Unique human-readable name of the Resource.
 2736        '''
 2737        self.override_database = override_database if override_database is not None else False
 2738        '''
 2739
 2740        '''
 2741        self.password = password if password is not None else ''
 2742        '''
 2743
 2744        '''
 2745        self.port = port if port is not None else 0
 2746        '''
 2747
 2748        '''
 2749        self.port_override = port_override if port_override is not None else 0
 2750        '''
 2751
 2752        '''
 2753        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2754        '''
 2755         ID of the secret store containing credentials for this resource, if any.
 2756        '''
 2757        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2758        '''
 2759         Tags is a map of key, value pairs.
 2760        '''
 2761        self.username = username if username is not None else ''
 2762        '''
 2763
 2764        '''
 2765
 2766    def __repr__(self):
 2767        return '<sdm.AzurePostgres ' + \
 2768            'database: ' + repr(self.database) + ' ' +\
 2769            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2770            'healthy: ' + repr(self.healthy) + ' ' +\
 2771            'hostname: ' + repr(self.hostname) + ' ' +\
 2772            'id: ' + repr(self.id) + ' ' +\
 2773            'name: ' + repr(self.name) + ' ' +\
 2774            'override_database: ' + repr(self.override_database) + ' ' +\
 2775            'password: ' + repr(self.password) + ' ' +\
 2776            'port: ' + repr(self.port) + ' ' +\
 2777            'port_override: ' + repr(self.port_override) + ' ' +\
 2778            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2779            'tags: ' + repr(self.tags) + ' ' +\
 2780            'username: ' + repr(self.username) + ' ' +\
 2781            '>'
 2782
 2783    def to_dict(self):
 2784        return {
 2785            'database': self.database,
 2786            'egress_filter': self.egress_filter,
 2787            'healthy': self.healthy,
 2788            'hostname': self.hostname,
 2789            'id': self.id,
 2790            'name': self.name,
 2791            'override_database': self.override_database,
 2792            'password': self.password,
 2793            'port': self.port,
 2794            'port_override': self.port_override,
 2795            'secret_store_id': self.secret_store_id,
 2796            'tags': self.tags,
 2797            'username': self.username,
 2798        }
 2799
 2800    @classmethod
 2801    def from_dict(cls, d):
 2802        return cls(
 2803            database=d.get('database'),
 2804            egress_filter=d.get('egress_filter'),
 2805            healthy=d.get('healthy'),
 2806            hostname=d.get('hostname'),
 2807            id=d.get('id'),
 2808            name=d.get('name'),
 2809            override_database=d.get('override_database'),
 2810            password=d.get('password'),
 2811            port=d.get('port'),
 2812            port_override=d.get('port_override'),
 2813            secret_store_id=d.get('secret_store_id'),
 2814            tags=d.get('tags'),
 2815            username=d.get('username'),
 2816        )
 2817
 2818
 2819class AzureStore:
 2820    '''
 2821
 2822    '''
 2823    __slots__ = [
 2824        'id',
 2825        'name',
 2826        'tags',
 2827        'vault_uri',
 2828    ]
 2829
 2830    def __init__(
 2831        self,
 2832        id=None,
 2833        name=None,
 2834        tags=None,
 2835        vault_uri=None,
 2836    ):
 2837        self.id = id if id is not None else ''
 2838        '''
 2839         Unique identifier of the SecretStore.
 2840        '''
 2841        self.name = name if name is not None else ''
 2842        '''
 2843         Unique human-readable name of the SecretStore.
 2844        '''
 2845        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2846        '''
 2847         Tags is a map of key, value pairs.
 2848        '''
 2849        self.vault_uri = vault_uri if vault_uri is not None else ''
 2850        '''
 2851
 2852        '''
 2853
 2854    def __repr__(self):
 2855        return '<sdm.AzureStore ' + \
 2856            'id: ' + repr(self.id) + ' ' +\
 2857            'name: ' + repr(self.name) + ' ' +\
 2858            'tags: ' + repr(self.tags) + ' ' +\
 2859            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 2860            '>'
 2861
 2862    def to_dict(self):
 2863        return {
 2864            'id': self.id,
 2865            'name': self.name,
 2866            'tags': self.tags,
 2867            'vault_uri': self.vault_uri,
 2868        }
 2869
 2870    @classmethod
 2871    def from_dict(cls, d):
 2872        return cls(
 2873            id=d.get('id'),
 2874            name=d.get('name'),
 2875            tags=d.get('tags'),
 2876            vault_uri=d.get('vault_uri'),
 2877        )
 2878
 2879
 2880class BigQuery:
 2881    '''
 2882
 2883    '''
 2884    __slots__ = [
 2885        'egress_filter',
 2886        'endpoint',
 2887        'healthy',
 2888        'id',
 2889        'name',
 2890        'port_override',
 2891        'private_key',
 2892        'project',
 2893        'secret_store_id',
 2894        'tags',
 2895        'username',
 2896    ]
 2897
 2898    def __init__(
 2899        self,
 2900        egress_filter=None,
 2901        endpoint=None,
 2902        healthy=None,
 2903        id=None,
 2904        name=None,
 2905        port_override=None,
 2906        private_key=None,
 2907        project=None,
 2908        secret_store_id=None,
 2909        tags=None,
 2910        username=None,
 2911    ):
 2912        self.egress_filter = egress_filter if egress_filter is not None else ''
 2913        '''
 2914         A filter applied to the routing logic to pin datasource to nodes.
 2915        '''
 2916        self.endpoint = endpoint if endpoint is not None else ''
 2917        '''
 2918
 2919        '''
 2920        self.healthy = healthy if healthy is not None else False
 2921        '''
 2922         True if the datasource is reachable and the credentials are valid.
 2923        '''
 2924        self.id = id if id is not None else ''
 2925        '''
 2926         Unique identifier of the Resource.
 2927        '''
 2928        self.name = name if name is not None else ''
 2929        '''
 2930         Unique human-readable name of the Resource.
 2931        '''
 2932        self.port_override = port_override if port_override is not None else 0
 2933        '''
 2934
 2935        '''
 2936        self.private_key = private_key if private_key is not None else ''
 2937        '''
 2938
 2939        '''
 2940        self.project = project if project is not None else ''
 2941        '''
 2942
 2943        '''
 2944        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2945        '''
 2946         ID of the secret store containing credentials for this resource, if any.
 2947        '''
 2948        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2949        '''
 2950         Tags is a map of key, value pairs.
 2951        '''
 2952        self.username = username if username is not None else ''
 2953        '''
 2954
 2955        '''
 2956
 2957    def __repr__(self):
 2958        return '<sdm.BigQuery ' + \
 2959            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2960            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2961            'healthy: ' + repr(self.healthy) + ' ' +\
 2962            'id: ' + repr(self.id) + ' ' +\
 2963            'name: ' + repr(self.name) + ' ' +\
 2964            'port_override: ' + repr(self.port_override) + ' ' +\
 2965            'private_key: ' + repr(self.private_key) + ' ' +\
 2966            'project: ' + repr(self.project) + ' ' +\
 2967            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2968            'tags: ' + repr(self.tags) + ' ' +\
 2969            'username: ' + repr(self.username) + ' ' +\
 2970            '>'
 2971
 2972    def to_dict(self):
 2973        return {
 2974            'egress_filter': self.egress_filter,
 2975            'endpoint': self.endpoint,
 2976            'healthy': self.healthy,
 2977            'id': self.id,
 2978            'name': self.name,
 2979            'port_override': self.port_override,
 2980            'private_key': self.private_key,
 2981            'project': self.project,
 2982            'secret_store_id': self.secret_store_id,
 2983            'tags': self.tags,
 2984            'username': self.username,
 2985        }
 2986
 2987    @classmethod
 2988    def from_dict(cls, d):
 2989        return cls(
 2990            egress_filter=d.get('egress_filter'),
 2991            endpoint=d.get('endpoint'),
 2992            healthy=d.get('healthy'),
 2993            id=d.get('id'),
 2994            name=d.get('name'),
 2995            port_override=d.get('port_override'),
 2996            private_key=d.get('private_key'),
 2997            project=d.get('project'),
 2998            secret_store_id=d.get('secret_store_id'),
 2999            tags=d.get('tags'),
 3000            username=d.get('username'),
 3001        )
 3002
 3003
 3004class Cassandra:
 3005    '''
 3006
 3007    '''
 3008    __slots__ = [
 3009        'egress_filter',
 3010        'healthy',
 3011        'hostname',
 3012        'id',
 3013        'name',
 3014        'password',
 3015        'port',
 3016        'port_override',
 3017        'secret_store_id',
 3018        'tags',
 3019        'tls_required',
 3020        'username',
 3021    ]
 3022
 3023    def __init__(
 3024        self,
 3025        egress_filter=None,
 3026        healthy=None,
 3027        hostname=None,
 3028        id=None,
 3029        name=None,
 3030        password=None,
 3031        port=None,
 3032        port_override=None,
 3033        secret_store_id=None,
 3034        tags=None,
 3035        tls_required=None,
 3036        username=None,
 3037    ):
 3038        self.egress_filter = egress_filter if egress_filter is not None else ''
 3039        '''
 3040         A filter applied to the routing logic to pin datasource to nodes.
 3041        '''
 3042        self.healthy = healthy if healthy is not None else False
 3043        '''
 3044         True if the datasource is reachable and the credentials are valid.
 3045        '''
 3046        self.hostname = hostname if hostname is not None else ''
 3047        '''
 3048
 3049        '''
 3050        self.id = id if id is not None else ''
 3051        '''
 3052         Unique identifier of the Resource.
 3053        '''
 3054        self.name = name if name is not None else ''
 3055        '''
 3056         Unique human-readable name of the Resource.
 3057        '''
 3058        self.password = password if password is not None else ''
 3059        '''
 3060
 3061        '''
 3062        self.port = port if port is not None else 0
 3063        '''
 3064
 3065        '''
 3066        self.port_override = port_override if port_override is not None else 0
 3067        '''
 3068
 3069        '''
 3070        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3071        '''
 3072         ID of the secret store containing credentials for this resource, if any.
 3073        '''
 3074        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3075        '''
 3076         Tags is a map of key, value pairs.
 3077        '''
 3078        self.tls_required = tls_required if tls_required is not None else False
 3079        '''
 3080
 3081        '''
 3082        self.username = username if username is not None else ''
 3083        '''
 3084
 3085        '''
 3086
 3087    def __repr__(self):
 3088        return '<sdm.Cassandra ' + \
 3089            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3090            'healthy: ' + repr(self.healthy) + ' ' +\
 3091            'hostname: ' + repr(self.hostname) + ' ' +\
 3092            'id: ' + repr(self.id) + ' ' +\
 3093            'name: ' + repr(self.name) + ' ' +\
 3094            'password: ' + repr(self.password) + ' ' +\
 3095            'port: ' + repr(self.port) + ' ' +\
 3096            'port_override: ' + repr(self.port_override) + ' ' +\
 3097            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3098            'tags: ' + repr(self.tags) + ' ' +\
 3099            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3100            'username: ' + repr(self.username) + ' ' +\
 3101            '>'
 3102
 3103    def to_dict(self):
 3104        return {
 3105            'egress_filter': self.egress_filter,
 3106            'healthy': self.healthy,
 3107            'hostname': self.hostname,
 3108            'id': self.id,
 3109            'name': self.name,
 3110            'password': self.password,
 3111            'port': self.port,
 3112            'port_override': self.port_override,
 3113            'secret_store_id': self.secret_store_id,
 3114            'tags': self.tags,
 3115            'tls_required': self.tls_required,
 3116            'username': self.username,
 3117        }
 3118
 3119    @classmethod
 3120    def from_dict(cls, d):
 3121        return cls(
 3122            egress_filter=d.get('egress_filter'),
 3123            healthy=d.get('healthy'),
 3124            hostname=d.get('hostname'),
 3125            id=d.get('id'),
 3126            name=d.get('name'),
 3127            password=d.get('password'),
 3128            port=d.get('port'),
 3129            port_override=d.get('port_override'),
 3130            secret_store_id=d.get('secret_store_id'),
 3131            tags=d.get('tags'),
 3132            tls_required=d.get('tls_required'),
 3133            username=d.get('username'),
 3134        )
 3135
 3136
 3137class Citus:
 3138    '''
 3139
 3140    '''
 3141    __slots__ = [
 3142        'database',
 3143        'egress_filter',
 3144        'healthy',
 3145        'hostname',
 3146        'id',
 3147        'name',
 3148        'override_database',
 3149        'password',
 3150        'port',
 3151        'port_override',
 3152        'secret_store_id',
 3153        'tags',
 3154        'username',
 3155    ]
 3156
 3157    def __init__(
 3158        self,
 3159        database=None,
 3160        egress_filter=None,
 3161        healthy=None,
 3162        hostname=None,
 3163        id=None,
 3164        name=None,
 3165        override_database=None,
 3166        password=None,
 3167        port=None,
 3168        port_override=None,
 3169        secret_store_id=None,
 3170        tags=None,
 3171        username=None,
 3172    ):
 3173        self.database = database if database is not None else ''
 3174        '''
 3175
 3176        '''
 3177        self.egress_filter = egress_filter if egress_filter is not None else ''
 3178        '''
 3179         A filter applied to the routing logic to pin datasource to nodes.
 3180        '''
 3181        self.healthy = healthy if healthy is not None else False
 3182        '''
 3183         True if the datasource is reachable and the credentials are valid.
 3184        '''
 3185        self.hostname = hostname if hostname is not None else ''
 3186        '''
 3187
 3188        '''
 3189        self.id = id if id is not None else ''
 3190        '''
 3191         Unique identifier of the Resource.
 3192        '''
 3193        self.name = name if name is not None else ''
 3194        '''
 3195         Unique human-readable name of the Resource.
 3196        '''
 3197        self.override_database = override_database if override_database is not None else False
 3198        '''
 3199
 3200        '''
 3201        self.password = password if password is not None else ''
 3202        '''
 3203
 3204        '''
 3205        self.port = port if port is not None else 0
 3206        '''
 3207
 3208        '''
 3209        self.port_override = port_override if port_override is not None else 0
 3210        '''
 3211
 3212        '''
 3213        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3214        '''
 3215         ID of the secret store containing credentials for this resource, if any.
 3216        '''
 3217        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3218        '''
 3219         Tags is a map of key, value pairs.
 3220        '''
 3221        self.username = username if username is not None else ''
 3222        '''
 3223
 3224        '''
 3225
 3226    def __repr__(self):
 3227        return '<sdm.Citus ' + \
 3228            'database: ' + repr(self.database) + ' ' +\
 3229            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3230            'healthy: ' + repr(self.healthy) + ' ' +\
 3231            'hostname: ' + repr(self.hostname) + ' ' +\
 3232            'id: ' + repr(self.id) + ' ' +\
 3233            'name: ' + repr(self.name) + ' ' +\
 3234            'override_database: ' + repr(self.override_database) + ' ' +\
 3235            'password: ' + repr(self.password) + ' ' +\
 3236            'port: ' + repr(self.port) + ' ' +\
 3237            'port_override: ' + repr(self.port_override) + ' ' +\
 3238            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3239            'tags: ' + repr(self.tags) + ' ' +\
 3240            'username: ' + repr(self.username) + ' ' +\
 3241            '>'
 3242
 3243    def to_dict(self):
 3244        return {
 3245            'database': self.database,
 3246            'egress_filter': self.egress_filter,
 3247            'healthy': self.healthy,
 3248            'hostname': self.hostname,
 3249            'id': self.id,
 3250            'name': self.name,
 3251            'override_database': self.override_database,
 3252            'password': self.password,
 3253            'port': self.port,
 3254            'port_override': self.port_override,
 3255            'secret_store_id': self.secret_store_id,
 3256            'tags': self.tags,
 3257            'username': self.username,
 3258        }
 3259
 3260    @classmethod
 3261    def from_dict(cls, d):
 3262        return cls(
 3263            database=d.get('database'),
 3264            egress_filter=d.get('egress_filter'),
 3265            healthy=d.get('healthy'),
 3266            hostname=d.get('hostname'),
 3267            id=d.get('id'),
 3268            name=d.get('name'),
 3269            override_database=d.get('override_database'),
 3270            password=d.get('password'),
 3271            port=d.get('port'),
 3272            port_override=d.get('port_override'),
 3273            secret_store_id=d.get('secret_store_id'),
 3274            tags=d.get('tags'),
 3275            username=d.get('username'),
 3276        )
 3277
 3278
 3279class Clustrix:
 3280    '''
 3281
 3282    '''
 3283    __slots__ = [
 3284        'database',
 3285        'egress_filter',
 3286        'healthy',
 3287        'hostname',
 3288        'id',
 3289        'name',
 3290        'password',
 3291        'port',
 3292        'port_override',
 3293        'secret_store_id',
 3294        'tags',
 3295        'username',
 3296    ]
 3297
 3298    def __init__(
 3299        self,
 3300        database=None,
 3301        egress_filter=None,
 3302        healthy=None,
 3303        hostname=None,
 3304        id=None,
 3305        name=None,
 3306        password=None,
 3307        port=None,
 3308        port_override=None,
 3309        secret_store_id=None,
 3310        tags=None,
 3311        username=None,
 3312    ):
 3313        self.database = database if database is not None else ''
 3314        '''
 3315
 3316        '''
 3317        self.egress_filter = egress_filter if egress_filter is not None else ''
 3318        '''
 3319         A filter applied to the routing logic to pin datasource to nodes.
 3320        '''
 3321        self.healthy = healthy if healthy is not None else False
 3322        '''
 3323         True if the datasource is reachable and the credentials are valid.
 3324        '''
 3325        self.hostname = hostname if hostname is not None else ''
 3326        '''
 3327
 3328        '''
 3329        self.id = id if id is not None else ''
 3330        '''
 3331         Unique identifier of the Resource.
 3332        '''
 3333        self.name = name if name is not None else ''
 3334        '''
 3335         Unique human-readable name of the Resource.
 3336        '''
 3337        self.password = password if password is not None else ''
 3338        '''
 3339
 3340        '''
 3341        self.port = port if port is not None else 0
 3342        '''
 3343
 3344        '''
 3345        self.port_override = port_override if port_override is not None else 0
 3346        '''
 3347
 3348        '''
 3349        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3350        '''
 3351         ID of the secret store containing credentials for this resource, if any.
 3352        '''
 3353        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3354        '''
 3355         Tags is a map of key, value pairs.
 3356        '''
 3357        self.username = username if username is not None else ''
 3358        '''
 3359
 3360        '''
 3361
 3362    def __repr__(self):
 3363        return '<sdm.Clustrix ' + \
 3364            'database: ' + repr(self.database) + ' ' +\
 3365            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3366            'healthy: ' + repr(self.healthy) + ' ' +\
 3367            'hostname: ' + repr(self.hostname) + ' ' +\
 3368            'id: ' + repr(self.id) + ' ' +\
 3369            'name: ' + repr(self.name) + ' ' +\
 3370            'password: ' + repr(self.password) + ' ' +\
 3371            'port: ' + repr(self.port) + ' ' +\
 3372            'port_override: ' + repr(self.port_override) + ' ' +\
 3373            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3374            'tags: ' + repr(self.tags) + ' ' +\
 3375            'username: ' + repr(self.username) + ' ' +\
 3376            '>'
 3377
 3378    def to_dict(self):
 3379        return {
 3380            'database': self.database,
 3381            'egress_filter': self.egress_filter,
 3382            'healthy': self.healthy,
 3383            'hostname': self.hostname,
 3384            'id': self.id,
 3385            'name': self.name,
 3386            'password': self.password,
 3387            'port': self.port,
 3388            'port_override': self.port_override,
 3389            'secret_store_id': self.secret_store_id,
 3390            'tags': self.tags,
 3391            'username': self.username,
 3392        }
 3393
 3394    @classmethod
 3395    def from_dict(cls, d):
 3396        return cls(
 3397            database=d.get('database'),
 3398            egress_filter=d.get('egress_filter'),
 3399            healthy=d.get('healthy'),
 3400            hostname=d.get('hostname'),
 3401            id=d.get('id'),
 3402            name=d.get('name'),
 3403            password=d.get('password'),
 3404            port=d.get('port'),
 3405            port_override=d.get('port_override'),
 3406            secret_store_id=d.get('secret_store_id'),
 3407            tags=d.get('tags'),
 3408            username=d.get('username'),
 3409        )
 3410
 3411
 3412class Cockroach:
 3413    '''
 3414
 3415    '''
 3416    __slots__ = [
 3417        'database',
 3418        'egress_filter',
 3419        'healthy',
 3420        'hostname',
 3421        'id',
 3422        'name',
 3423        'override_database',
 3424        'password',
 3425        'port',
 3426        'port_override',
 3427        'secret_store_id',
 3428        'tags',
 3429        'username',
 3430    ]
 3431
 3432    def __init__(
 3433        self,
 3434        database=None,
 3435        egress_filter=None,
 3436        healthy=None,
 3437        hostname=None,
 3438        id=None,
 3439        name=None,
 3440        override_database=None,
 3441        password=None,
 3442        port=None,
 3443        port_override=None,
 3444        secret_store_id=None,
 3445        tags=None,
 3446        username=None,
 3447    ):
 3448        self.database = database if database is not None else ''
 3449        '''
 3450
 3451        '''
 3452        self.egress_filter = egress_filter if egress_filter is not None else ''
 3453        '''
 3454         A filter applied to the routing logic to pin datasource to nodes.
 3455        '''
 3456        self.healthy = healthy if healthy is not None else False
 3457        '''
 3458         True if the datasource is reachable and the credentials are valid.
 3459        '''
 3460        self.hostname = hostname if hostname is not None else ''
 3461        '''
 3462
 3463        '''
 3464        self.id = id if id is not None else ''
 3465        '''
 3466         Unique identifier of the Resource.
 3467        '''
 3468        self.name = name if name is not None else ''
 3469        '''
 3470         Unique human-readable name of the Resource.
 3471        '''
 3472        self.override_database = override_database if override_database is not None else False
 3473        '''
 3474
 3475        '''
 3476        self.password = password if password is not None else ''
 3477        '''
 3478
 3479        '''
 3480        self.port = port if port is not None else 0
 3481        '''
 3482
 3483        '''
 3484        self.port_override = port_override if port_override is not None else 0
 3485        '''
 3486
 3487        '''
 3488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3489        '''
 3490         ID of the secret store containing credentials for this resource, if any.
 3491        '''
 3492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3493        '''
 3494         Tags is a map of key, value pairs.
 3495        '''
 3496        self.username = username if username is not None else ''
 3497        '''
 3498
 3499        '''
 3500
 3501    def __repr__(self):
 3502        return '<sdm.Cockroach ' + \
 3503            'database: ' + repr(self.database) + ' ' +\
 3504            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3505            'healthy: ' + repr(self.healthy) + ' ' +\
 3506            'hostname: ' + repr(self.hostname) + ' ' +\
 3507            'id: ' + repr(self.id) + ' ' +\
 3508            'name: ' + repr(self.name) + ' ' +\
 3509            'override_database: ' + repr(self.override_database) + ' ' +\
 3510            'password: ' + repr(self.password) + ' ' +\
 3511            'port: ' + repr(self.port) + ' ' +\
 3512            'port_override: ' + repr(self.port_override) + ' ' +\
 3513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3514            'tags: ' + repr(self.tags) + ' ' +\
 3515            'username: ' + repr(self.username) + ' ' +\
 3516            '>'
 3517
 3518    def to_dict(self):
 3519        return {
 3520            'database': self.database,
 3521            'egress_filter': self.egress_filter,
 3522            'healthy': self.healthy,
 3523            'hostname': self.hostname,
 3524            'id': self.id,
 3525            'name': self.name,
 3526            'override_database': self.override_database,
 3527            'password': self.password,
 3528            'port': self.port,
 3529            'port_override': self.port_override,
 3530            'secret_store_id': self.secret_store_id,
 3531            'tags': self.tags,
 3532            'username': self.username,
 3533        }
 3534
 3535    @classmethod
 3536    def from_dict(cls, d):
 3537        return cls(
 3538            database=d.get('database'),
 3539            egress_filter=d.get('egress_filter'),
 3540            healthy=d.get('healthy'),
 3541            hostname=d.get('hostname'),
 3542            id=d.get('id'),
 3543            name=d.get('name'),
 3544            override_database=d.get('override_database'),
 3545            password=d.get('password'),
 3546            port=d.get('port'),
 3547            port_override=d.get('port_override'),
 3548            secret_store_id=d.get('secret_store_id'),
 3549            tags=d.get('tags'),
 3550            username=d.get('username'),
 3551        )
 3552
 3553
 3554class ControlPanelGetSSHCAPublicKeyResponse:
 3555    '''
 3556     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3557     organization's SSH Certificate Authority public key.
 3558    '''
 3559    __slots__ = [
 3560        'meta',
 3561        'public_key',
 3562        'rate_limit',
 3563    ]
 3564
 3565    def __init__(
 3566        self,
 3567        meta=None,
 3568        public_key=None,
 3569        rate_limit=None,
 3570    ):
 3571        self.meta = meta if meta is not None else None
 3572        '''
 3573         Reserved for future use.
 3574        '''
 3575        self.public_key = public_key if public_key is not None else ''
 3576        '''
 3577         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3578         key format.
 3579        '''
 3580        self.rate_limit = rate_limit if rate_limit is not None else None
 3581        '''
 3582         Rate limit information.
 3583        '''
 3584
 3585    def __repr__(self):
 3586        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3587            'meta: ' + repr(self.meta) + ' ' +\
 3588            'public_key: ' + repr(self.public_key) + ' ' +\
 3589            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3590            '>'
 3591
 3592    def to_dict(self):
 3593        return {
 3594            'meta': self.meta,
 3595            'public_key': self.public_key,
 3596            'rate_limit': self.rate_limit,
 3597        }
 3598
 3599    @classmethod
 3600    def from_dict(cls, d):
 3601        return cls(
 3602            meta=d.get('meta'),
 3603            public_key=d.get('public_key'),
 3604            rate_limit=d.get('rate_limit'),
 3605        )
 3606
 3607
 3608class ControlPanelVerifyJWTResponse:
 3609    '''
 3610     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3611    '''
 3612    __slots__ = [
 3613        'meta',
 3614        'rate_limit',
 3615        'valid',
 3616    ]
 3617
 3618    def __init__(
 3619        self,
 3620        meta=None,
 3621        rate_limit=None,
 3622        valid=None,
 3623    ):
 3624        self.meta = meta if meta is not None else None
 3625        '''
 3626         Reserved for future use.
 3627        '''
 3628        self.rate_limit = rate_limit if rate_limit is not None else None
 3629        '''
 3630         Rate limit information.
 3631        '''
 3632        self.valid = valid if valid is not None else False
 3633        '''
 3634         Reports if the given token is valid.
 3635        '''
 3636
 3637    def __repr__(self):
 3638        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3639            'meta: ' + repr(self.meta) + ' ' +\
 3640            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3641            'valid: ' + repr(self.valid) + ' ' +\
 3642            '>'
 3643
 3644    def to_dict(self):
 3645        return {
 3646            'meta': self.meta,
 3647            'rate_limit': self.rate_limit,
 3648            'valid': self.valid,
 3649        }
 3650
 3651    @classmethod
 3652    def from_dict(cls, d):
 3653        return cls(
 3654            meta=d.get('meta'),
 3655            rate_limit=d.get('rate_limit'),
 3656            valid=d.get('valid'),
 3657        )
 3658
 3659
 3660class CreateResponseMetadata:
 3661    '''
 3662     CreateResponseMetadata is reserved for future use.
 3663    '''
 3664    __slots__ = []
 3665
 3666    def __init__(self, ):
 3667        pass
 3668
 3669    def __repr__(self):
 3670        return '<sdm.CreateResponseMetadata ' + \
 3671            '>'
 3672
 3673    def to_dict(self):
 3674        return {}
 3675
 3676    @classmethod
 3677    def from_dict(cls, d):
 3678        return cls()
 3679
 3680
 3681class DB2I:
 3682    '''
 3683
 3684    '''
 3685    __slots__ = [
 3686        'egress_filter',
 3687        'healthy',
 3688        'hostname',
 3689        'id',
 3690        'name',
 3691        'password',
 3692        'port',
 3693        'port_override',
 3694        'secret_store_id',
 3695        'tags',
 3696        'tls_required',
 3697        'username',
 3698    ]
 3699
 3700    def __init__(
 3701        self,
 3702        egress_filter=None,
 3703        healthy=None,
 3704        hostname=None,
 3705        id=None,
 3706        name=None,
 3707        password=None,
 3708        port=None,
 3709        port_override=None,
 3710        secret_store_id=None,
 3711        tags=None,
 3712        tls_required=None,
 3713        username=None,
 3714    ):
 3715        self.egress_filter = egress_filter if egress_filter is not None else ''
 3716        '''
 3717         A filter applied to the routing logic to pin datasource to nodes.
 3718        '''
 3719        self.healthy = healthy if healthy is not None else False
 3720        '''
 3721         True if the datasource is reachable and the credentials are valid.
 3722        '''
 3723        self.hostname = hostname if hostname is not None else ''
 3724        '''
 3725
 3726        '''
 3727        self.id = id if id is not None else ''
 3728        '''
 3729         Unique identifier of the Resource.
 3730        '''
 3731        self.name = name if name is not None else ''
 3732        '''
 3733         Unique human-readable name of the Resource.
 3734        '''
 3735        self.password = password if password is not None else ''
 3736        '''
 3737
 3738        '''
 3739        self.port = port if port is not None else 0
 3740        '''
 3741
 3742        '''
 3743        self.port_override = port_override if port_override is not None else 0
 3744        '''
 3745
 3746        '''
 3747        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3748        '''
 3749         ID of the secret store containing credentials for this resource, if any.
 3750        '''
 3751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3752        '''
 3753         Tags is a map of key, value pairs.
 3754        '''
 3755        self.tls_required = tls_required if tls_required is not None else False
 3756        '''
 3757
 3758        '''
 3759        self.username = username if username is not None else ''
 3760        '''
 3761
 3762        '''
 3763
 3764    def __repr__(self):
 3765        return '<sdm.DB2I ' + \
 3766            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3767            'healthy: ' + repr(self.healthy) + ' ' +\
 3768            'hostname: ' + repr(self.hostname) + ' ' +\
 3769            'id: ' + repr(self.id) + ' ' +\
 3770            'name: ' + repr(self.name) + ' ' +\
 3771            'password: ' + repr(self.password) + ' ' +\
 3772            'port: ' + repr(self.port) + ' ' +\
 3773            'port_override: ' + repr(self.port_override) + ' ' +\
 3774            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3775            'tags: ' + repr(self.tags) + ' ' +\
 3776            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3777            'username: ' + repr(self.username) + ' ' +\
 3778            '>'
 3779
 3780    def to_dict(self):
 3781        return {
 3782            'egress_filter': self.egress_filter,
 3783            'healthy': self.healthy,
 3784            'hostname': self.hostname,
 3785            'id': self.id,
 3786            'name': self.name,
 3787            'password': self.password,
 3788            'port': self.port,
 3789            'port_override': self.port_override,
 3790            'secret_store_id': self.secret_store_id,
 3791            'tags': self.tags,
 3792            'tls_required': self.tls_required,
 3793            'username': self.username,
 3794        }
 3795
 3796    @classmethod
 3797    def from_dict(cls, d):
 3798        return cls(
 3799            egress_filter=d.get('egress_filter'),
 3800            healthy=d.get('healthy'),
 3801            hostname=d.get('hostname'),
 3802            id=d.get('id'),
 3803            name=d.get('name'),
 3804            password=d.get('password'),
 3805            port=d.get('port'),
 3806            port_override=d.get('port_override'),
 3807            secret_store_id=d.get('secret_store_id'),
 3808            tags=d.get('tags'),
 3809            tls_required=d.get('tls_required'),
 3810            username=d.get('username'),
 3811        )
 3812
 3813
 3814class DB2LUW:
 3815    '''
 3816
 3817    '''
 3818    __slots__ = [
 3819        'database',
 3820        'egress_filter',
 3821        'healthy',
 3822        'hostname',
 3823        'id',
 3824        'name',
 3825        'password',
 3826        'port',
 3827        'port_override',
 3828        'secret_store_id',
 3829        'tags',
 3830        'username',
 3831    ]
 3832
 3833    def __init__(
 3834        self,
 3835        database=None,
 3836        egress_filter=None,
 3837        healthy=None,
 3838        hostname=None,
 3839        id=None,
 3840        name=None,
 3841        password=None,
 3842        port=None,
 3843        port_override=None,
 3844        secret_store_id=None,
 3845        tags=None,
 3846        username=None,
 3847    ):
 3848        self.database = database if database is not None else ''
 3849        '''
 3850
 3851        '''
 3852        self.egress_filter = egress_filter if egress_filter is not None else ''
 3853        '''
 3854         A filter applied to the routing logic to pin datasource to nodes.
 3855        '''
 3856        self.healthy = healthy if healthy is not None else False
 3857        '''
 3858         True if the datasource is reachable and the credentials are valid.
 3859        '''
 3860        self.hostname = hostname if hostname is not None else ''
 3861        '''
 3862
 3863        '''
 3864        self.id = id if id is not None else ''
 3865        '''
 3866         Unique identifier of the Resource.
 3867        '''
 3868        self.name = name if name is not None else ''
 3869        '''
 3870         Unique human-readable name of the Resource.
 3871        '''
 3872        self.password = password if password is not None else ''
 3873        '''
 3874
 3875        '''
 3876        self.port = port if port is not None else 0
 3877        '''
 3878
 3879        '''
 3880        self.port_override = port_override if port_override is not None else 0
 3881        '''
 3882
 3883        '''
 3884        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3885        '''
 3886         ID of the secret store containing credentials for this resource, if any.
 3887        '''
 3888        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3889        '''
 3890         Tags is a map of key, value pairs.
 3891        '''
 3892        self.username = username if username is not None else ''
 3893        '''
 3894
 3895        '''
 3896
 3897    def __repr__(self):
 3898        return '<sdm.DB2LUW ' + \
 3899            'database: ' + repr(self.database) + ' ' +\
 3900            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3901            'healthy: ' + repr(self.healthy) + ' ' +\
 3902            'hostname: ' + repr(self.hostname) + ' ' +\
 3903            'id: ' + repr(self.id) + ' ' +\
 3904            'name: ' + repr(self.name) + ' ' +\
 3905            'password: ' + repr(self.password) + ' ' +\
 3906            'port: ' + repr(self.port) + ' ' +\
 3907            'port_override: ' + repr(self.port_override) + ' ' +\
 3908            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3909            'tags: ' + repr(self.tags) + ' ' +\
 3910            'username: ' + repr(self.username) + ' ' +\
 3911            '>'
 3912
 3913    def to_dict(self):
 3914        return {
 3915            'database': self.database,
 3916            'egress_filter': self.egress_filter,
 3917            'healthy': self.healthy,
 3918            'hostname': self.hostname,
 3919            'id': self.id,
 3920            'name': self.name,
 3921            'password': self.password,
 3922            'port': self.port,
 3923            'port_override': self.port_override,
 3924            'secret_store_id': self.secret_store_id,
 3925            'tags': self.tags,
 3926            'username': self.username,
 3927        }
 3928
 3929    @classmethod
 3930    def from_dict(cls, d):
 3931        return cls(
 3932            database=d.get('database'),
 3933            egress_filter=d.get('egress_filter'),
 3934            healthy=d.get('healthy'),
 3935            hostname=d.get('hostname'),
 3936            id=d.get('id'),
 3937            name=d.get('name'),
 3938            password=d.get('password'),
 3939            port=d.get('port'),
 3940            port_override=d.get('port_override'),
 3941            secret_store_id=d.get('secret_store_id'),
 3942            tags=d.get('tags'),
 3943            username=d.get('username'),
 3944        )
 3945
 3946
 3947class DeleteResponseMetadata:
 3948    '''
 3949     DeleteResponseMetadata is reserved for future use.
 3950    '''
 3951    __slots__ = []
 3952
 3953    def __init__(self, ):
 3954        pass
 3955
 3956    def __repr__(self):
 3957        return '<sdm.DeleteResponseMetadata ' + \
 3958            '>'
 3959
 3960    def to_dict(self):
 3961        return {}
 3962
 3963    @classmethod
 3964    def from_dict(cls, d):
 3965        return cls()
 3966
 3967
 3968class DocumentDBHost:
 3969    '''
 3970
 3971    '''
 3972    __slots__ = [
 3973        'auth_database',
 3974        'egress_filter',
 3975        'healthy',
 3976        'hostname',
 3977        'id',
 3978        'name',
 3979        'password',
 3980        'port',
 3981        'port_override',
 3982        'secret_store_id',
 3983        'tags',
 3984        'username',
 3985    ]
 3986
 3987    def __init__(
 3988        self,
 3989        auth_database=None,
 3990        egress_filter=None,
 3991        healthy=None,
 3992        hostname=None,
 3993        id=None,
 3994        name=None,
 3995        password=None,
 3996        port=None,
 3997        port_override=None,
 3998        secret_store_id=None,
 3999        tags=None,
 4000        username=None,
 4001    ):
 4002        self.auth_database = auth_database if auth_database is not None else ''
 4003        '''
 4004
 4005        '''
 4006        self.egress_filter = egress_filter if egress_filter is not None else ''
 4007        '''
 4008         A filter applied to the routing logic to pin datasource to nodes.
 4009        '''
 4010        self.healthy = healthy if healthy is not None else False
 4011        '''
 4012         True if the datasource is reachable and the credentials are valid.
 4013        '''
 4014        self.hostname = hostname if hostname is not None else ''
 4015        '''
 4016
 4017        '''
 4018        self.id = id if id is not None else ''
 4019        '''
 4020         Unique identifier of the Resource.
 4021        '''
 4022        self.name = name if name is not None else ''
 4023        '''
 4024         Unique human-readable name of the Resource.
 4025        '''
 4026        self.password = password if password is not None else ''
 4027        '''
 4028
 4029        '''
 4030        self.port = port if port is not None else 0
 4031        '''
 4032
 4033        '''
 4034        self.port_override = port_override if port_override is not None else 0
 4035        '''
 4036
 4037        '''
 4038        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4039        '''
 4040         ID of the secret store containing credentials for this resource, if any.
 4041        '''
 4042        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4043        '''
 4044         Tags is a map of key, value pairs.
 4045        '''
 4046        self.username = username if username is not None else ''
 4047        '''
 4048
 4049        '''
 4050
 4051    def __repr__(self):
 4052        return '<sdm.DocumentDBHost ' + \
 4053            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4054            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4055            'healthy: ' + repr(self.healthy) + ' ' +\
 4056            'hostname: ' + repr(self.hostname) + ' ' +\
 4057            'id: ' + repr(self.id) + ' ' +\
 4058            'name: ' + repr(self.name) + ' ' +\
 4059            'password: ' + repr(self.password) + ' ' +\
 4060            'port: ' + repr(self.port) + ' ' +\
 4061            'port_override: ' + repr(self.port_override) + ' ' +\
 4062            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4063            'tags: ' + repr(self.tags) + ' ' +\
 4064            'username: ' + repr(self.username) + ' ' +\
 4065            '>'
 4066
 4067    def to_dict(self):
 4068        return {
 4069            'auth_database': self.auth_database,
 4070            'egress_filter': self.egress_filter,
 4071            'healthy': self.healthy,
 4072            'hostname': self.hostname,
 4073            'id': self.id,
 4074            'name': self.name,
 4075            'password': self.password,
 4076            'port': self.port,
 4077            'port_override': self.port_override,
 4078            'secret_store_id': self.secret_store_id,
 4079            'tags': self.tags,
 4080            'username': self.username,
 4081        }
 4082
 4083    @classmethod
 4084    def from_dict(cls, d):
 4085        return cls(
 4086            auth_database=d.get('auth_database'),
 4087            egress_filter=d.get('egress_filter'),
 4088            healthy=d.get('healthy'),
 4089            hostname=d.get('hostname'),
 4090            id=d.get('id'),
 4091            name=d.get('name'),
 4092            password=d.get('password'),
 4093            port=d.get('port'),
 4094            port_override=d.get('port_override'),
 4095            secret_store_id=d.get('secret_store_id'),
 4096            tags=d.get('tags'),
 4097            username=d.get('username'),
 4098        )
 4099
 4100
 4101class DocumentDBReplicaSet:
 4102    '''
 4103
 4104    '''
 4105    __slots__ = [
 4106        'auth_database',
 4107        'connect_to_replica',
 4108        'egress_filter',
 4109        'healthy',
 4110        'hostname',
 4111        'id',
 4112        'name',
 4113        'password',
 4114        'port_override',
 4115        'replica_set',
 4116        'secret_store_id',
 4117        'tags',
 4118        'username',
 4119    ]
 4120
 4121    def __init__(
 4122        self,
 4123        auth_database=None,
 4124        connect_to_replica=None,
 4125        egress_filter=None,
 4126        healthy=None,
 4127        hostname=None,
 4128        id=None,
 4129        name=None,
 4130        password=None,
 4131        port_override=None,
 4132        replica_set=None,
 4133        secret_store_id=None,
 4134        tags=None,
 4135        username=None,
 4136    ):
 4137        self.auth_database = auth_database if auth_database is not None else ''
 4138        '''
 4139
 4140        '''
 4141        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4142        '''
 4143
 4144        '''
 4145        self.egress_filter = egress_filter if egress_filter is not None else ''
 4146        '''
 4147         A filter applied to the routing logic to pin datasource to nodes.
 4148        '''
 4149        self.healthy = healthy if healthy is not None else False
 4150        '''
 4151         True if the datasource is reachable and the credentials are valid.
 4152        '''
 4153        self.hostname = hostname if hostname is not None else ''
 4154        '''
 4155         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4156        '''
 4157        self.id = id if id is not None else ''
 4158        '''
 4159         Unique identifier of the Resource.
 4160        '''
 4161        self.name = name if name is not None else ''
 4162        '''
 4163         Unique human-readable name of the Resource.
 4164        '''
 4165        self.password = password if password is not None else ''
 4166        '''
 4167
 4168        '''
 4169        self.port_override = port_override if port_override is not None else 0
 4170        '''
 4171
 4172        '''
 4173        self.replica_set = replica_set if replica_set is not None else ''
 4174        '''
 4175
 4176        '''
 4177        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4178        '''
 4179         ID of the secret store containing credentials for this resource, if any.
 4180        '''
 4181        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4182        '''
 4183         Tags is a map of key, value pairs.
 4184        '''
 4185        self.username = username if username is not None else ''
 4186        '''
 4187
 4188        '''
 4189
 4190    def __repr__(self):
 4191        return '<sdm.DocumentDBReplicaSet ' + \
 4192            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4193            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4195            'healthy: ' + repr(self.healthy) + ' ' +\
 4196            'hostname: ' + repr(self.hostname) + ' ' +\
 4197            'id: ' + repr(self.id) + ' ' +\
 4198            'name: ' + repr(self.name) + ' ' +\
 4199            'password: ' + repr(self.password) + ' ' +\
 4200            'port_override: ' + repr(self.port_override) + ' ' +\
 4201            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4202            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4203            'tags: ' + repr(self.tags) + ' ' +\
 4204            'username: ' + repr(self.username) + ' ' +\
 4205            '>'
 4206
 4207    def to_dict(self):
 4208        return {
 4209            'auth_database': self.auth_database,
 4210            'connect_to_replica': self.connect_to_replica,
 4211            'egress_filter': self.egress_filter,
 4212            'healthy': self.healthy,
 4213            'hostname': self.hostname,
 4214            'id': self.id,
 4215            'name': self.name,
 4216            'password': self.password,
 4217            'port_override': self.port_override,
 4218            'replica_set': self.replica_set,
 4219            'secret_store_id': self.secret_store_id,
 4220            'tags': self.tags,
 4221            'username': self.username,
 4222        }
 4223
 4224    @classmethod
 4225    def from_dict(cls, d):
 4226        return cls(
 4227            auth_database=d.get('auth_database'),
 4228            connect_to_replica=d.get('connect_to_replica'),
 4229            egress_filter=d.get('egress_filter'),
 4230            healthy=d.get('healthy'),
 4231            hostname=d.get('hostname'),
 4232            id=d.get('id'),
 4233            name=d.get('name'),
 4234            password=d.get('password'),
 4235            port_override=d.get('port_override'),
 4236            replica_set=d.get('replica_set'),
 4237            secret_store_id=d.get('secret_store_id'),
 4238            tags=d.get('tags'),
 4239            username=d.get('username'),
 4240        )
 4241
 4242
 4243class Druid:
 4244    '''
 4245
 4246    '''
 4247    __slots__ = [
 4248        'egress_filter',
 4249        'healthy',
 4250        'hostname',
 4251        'id',
 4252        'name',
 4253        'password',
 4254        'port',
 4255        'port_override',
 4256        'secret_store_id',
 4257        'tags',
 4258        'username',
 4259    ]
 4260
 4261    def __init__(
 4262        self,
 4263        egress_filter=None,
 4264        healthy=None,
 4265        hostname=None,
 4266        id=None,
 4267        name=None,
 4268        password=None,
 4269        port=None,
 4270        port_override=None,
 4271        secret_store_id=None,
 4272        tags=None,
 4273        username=None,
 4274    ):
 4275        self.egress_filter = egress_filter if egress_filter is not None else ''
 4276        '''
 4277         A filter applied to the routing logic to pin datasource to nodes.
 4278        '''
 4279        self.healthy = healthy if healthy is not None else False
 4280        '''
 4281         True if the datasource is reachable and the credentials are valid.
 4282        '''
 4283        self.hostname = hostname if hostname is not None else ''
 4284        '''
 4285
 4286        '''
 4287        self.id = id if id is not None else ''
 4288        '''
 4289         Unique identifier of the Resource.
 4290        '''
 4291        self.name = name if name is not None else ''
 4292        '''
 4293         Unique human-readable name of the Resource.
 4294        '''
 4295        self.password = password if password is not None else ''
 4296        '''
 4297
 4298        '''
 4299        self.port = port if port is not None else 0
 4300        '''
 4301
 4302        '''
 4303        self.port_override = port_override if port_override is not None else 0
 4304        '''
 4305
 4306        '''
 4307        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4308        '''
 4309         ID of the secret store containing credentials for this resource, if any.
 4310        '''
 4311        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4312        '''
 4313         Tags is a map of key, value pairs.
 4314        '''
 4315        self.username = username if username is not None else ''
 4316        '''
 4317
 4318        '''
 4319
 4320    def __repr__(self):
 4321        return '<sdm.Druid ' + \
 4322            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4323            'healthy: ' + repr(self.healthy) + ' ' +\
 4324            'hostname: ' + repr(self.hostname) + ' ' +\
 4325            'id: ' + repr(self.id) + ' ' +\
 4326            'name: ' + repr(self.name) + ' ' +\
 4327            'password: ' + repr(self.password) + ' ' +\
 4328            'port: ' + repr(self.port) + ' ' +\
 4329            'port_override: ' + repr(self.port_override) + ' ' +\
 4330            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4331            'tags: ' + repr(self.tags) + ' ' +\
 4332            'username: ' + repr(self.username) + ' ' +\
 4333            '>'
 4334
 4335    def to_dict(self):
 4336        return {
 4337            'egress_filter': self.egress_filter,
 4338            'healthy': self.healthy,
 4339            'hostname': self.hostname,
 4340            'id': self.id,
 4341            'name': self.name,
 4342            'password': self.password,
 4343            'port': self.port,
 4344            'port_override': self.port_override,
 4345            'secret_store_id': self.secret_store_id,
 4346            'tags': self.tags,
 4347            'username': self.username,
 4348        }
 4349
 4350    @classmethod
 4351    def from_dict(cls, d):
 4352        return cls(
 4353            egress_filter=d.get('egress_filter'),
 4354            healthy=d.get('healthy'),
 4355            hostname=d.get('hostname'),
 4356            id=d.get('id'),
 4357            name=d.get('name'),
 4358            password=d.get('password'),
 4359            port=d.get('port'),
 4360            port_override=d.get('port_override'),
 4361            secret_store_id=d.get('secret_store_id'),
 4362            tags=d.get('tags'),
 4363            username=d.get('username'),
 4364        )
 4365
 4366
 4367class DynamoDB:
 4368    '''
 4369
 4370    '''
 4371    __slots__ = [
 4372        'access_key',
 4373        'egress_filter',
 4374        'endpoint',
 4375        'healthy',
 4376        'id',
 4377        'name',
 4378        'port_override',
 4379        'region',
 4380        'role_arn',
 4381        'role_external_id',
 4382        'secret_access_key',
 4383        'secret_store_id',
 4384        'tags',
 4385    ]
 4386
 4387    def __init__(
 4388        self,
 4389        access_key=None,
 4390        egress_filter=None,
 4391        endpoint=None,
 4392        healthy=None,
 4393        id=None,
 4394        name=None,
 4395        port_override=None,
 4396        region=None,
 4397        role_arn=None,
 4398        role_external_id=None,
 4399        secret_access_key=None,
 4400        secret_store_id=None,
 4401        tags=None,
 4402    ):
 4403        self.access_key = access_key if access_key is not None else ''
 4404        '''
 4405
 4406        '''
 4407        self.egress_filter = egress_filter if egress_filter is not None else ''
 4408        '''
 4409         A filter applied to the routing logic to pin datasource to nodes.
 4410        '''
 4411        self.endpoint = endpoint if endpoint is not None else ''
 4412        '''
 4413
 4414        '''
 4415        self.healthy = healthy if healthy is not None else False
 4416        '''
 4417         True if the datasource is reachable and the credentials are valid.
 4418        '''
 4419        self.id = id if id is not None else ''
 4420        '''
 4421         Unique identifier of the Resource.
 4422        '''
 4423        self.name = name if name is not None else ''
 4424        '''
 4425         Unique human-readable name of the Resource.
 4426        '''
 4427        self.port_override = port_override if port_override is not None else 0
 4428        '''
 4429
 4430        '''
 4431        self.region = region if region is not None else ''
 4432        '''
 4433
 4434        '''
 4435        self.role_arn = role_arn if role_arn is not None else ''
 4436        '''
 4437
 4438        '''
 4439        self.role_external_id = role_external_id if role_external_id is not None else ''
 4440        '''
 4441
 4442        '''
 4443        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4444        '''
 4445
 4446        '''
 4447        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4448        '''
 4449         ID of the secret store containing credentials for this resource, if any.
 4450        '''
 4451        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4452        '''
 4453         Tags is a map of key, value pairs.
 4454        '''
 4455
 4456    def __repr__(self):
 4457        return '<sdm.DynamoDB ' + \
 4458            'access_key: ' + repr(self.access_key) + ' ' +\
 4459            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4460            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4461            'healthy: ' + repr(self.healthy) + ' ' +\
 4462            'id: ' + repr(self.id) + ' ' +\
 4463            'name: ' + repr(self.name) + ' ' +\
 4464            'port_override: ' + repr(self.port_override) + ' ' +\
 4465            'region: ' + repr(self.region) + ' ' +\
 4466            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4467            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4468            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4469            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4470            'tags: ' + repr(self.tags) + ' ' +\
 4471            '>'
 4472
 4473    def to_dict(self):
 4474        return {
 4475            'access_key': self.access_key,
 4476            'egress_filter': self.egress_filter,
 4477            'endpoint': self.endpoint,
 4478            'healthy': self.healthy,
 4479            'id': self.id,
 4480            'name': self.name,
 4481            'port_override': self.port_override,
 4482            'region': self.region,
 4483            'role_arn': self.role_arn,
 4484            'role_external_id': self.role_external_id,
 4485            'secret_access_key': self.secret_access_key,
 4486            'secret_store_id': self.secret_store_id,
 4487            'tags': self.tags,
 4488        }
 4489
 4490    @classmethod
 4491    def from_dict(cls, d):
 4492        return cls(
 4493            access_key=d.get('access_key'),
 4494            egress_filter=d.get('egress_filter'),
 4495            endpoint=d.get('endpoint'),
 4496            healthy=d.get('healthy'),
 4497            id=d.get('id'),
 4498            name=d.get('name'),
 4499            port_override=d.get('port_override'),
 4500            region=d.get('region'),
 4501            role_arn=d.get('role_arn'),
 4502            role_external_id=d.get('role_external_id'),
 4503            secret_access_key=d.get('secret_access_key'),
 4504            secret_store_id=d.get('secret_store_id'),
 4505            tags=d.get('tags'),
 4506        )
 4507
 4508
 4509class Elastic:
 4510    '''
 4511
 4512    '''
 4513    __slots__ = [
 4514        'egress_filter',
 4515        'healthy',
 4516        'hostname',
 4517        'id',
 4518        'name',
 4519        'password',
 4520        'port',
 4521        'port_override',
 4522        'secret_store_id',
 4523        'tags',
 4524        'tls_required',
 4525        'username',
 4526    ]
 4527
 4528    def __init__(
 4529        self,
 4530        egress_filter=None,
 4531        healthy=None,
 4532        hostname=None,
 4533        id=None,
 4534        name=None,
 4535        password=None,
 4536        port=None,
 4537        port_override=None,
 4538        secret_store_id=None,
 4539        tags=None,
 4540        tls_required=None,
 4541        username=None,
 4542    ):
 4543        self.egress_filter = egress_filter if egress_filter is not None else ''
 4544        '''
 4545         A filter applied to the routing logic to pin datasource to nodes.
 4546        '''
 4547        self.healthy = healthy if healthy is not None else False
 4548        '''
 4549         True if the datasource is reachable and the credentials are valid.
 4550        '''
 4551        self.hostname = hostname if hostname is not None else ''
 4552        '''
 4553
 4554        '''
 4555        self.id = id if id is not None else ''
 4556        '''
 4557         Unique identifier of the Resource.
 4558        '''
 4559        self.name = name if name is not None else ''
 4560        '''
 4561         Unique human-readable name of the Resource.
 4562        '''
 4563        self.password = password if password is not None else ''
 4564        '''
 4565
 4566        '''
 4567        self.port = port if port is not None else 0
 4568        '''
 4569
 4570        '''
 4571        self.port_override = port_override if port_override is not None else 0
 4572        '''
 4573
 4574        '''
 4575        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4576        '''
 4577         ID of the secret store containing credentials for this resource, if any.
 4578        '''
 4579        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4580        '''
 4581         Tags is a map of key, value pairs.
 4582        '''
 4583        self.tls_required = tls_required if tls_required is not None else False
 4584        '''
 4585
 4586        '''
 4587        self.username = username if username is not None else ''
 4588        '''
 4589
 4590        '''
 4591
 4592    def __repr__(self):
 4593        return '<sdm.Elastic ' + \
 4594            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4595            'healthy: ' + repr(self.healthy) + ' ' +\
 4596            'hostname: ' + repr(self.hostname) + ' ' +\
 4597            'id: ' + repr(self.id) + ' ' +\
 4598            'name: ' + repr(self.name) + ' ' +\
 4599            'password: ' + repr(self.password) + ' ' +\
 4600            'port: ' + repr(self.port) + ' ' +\
 4601            'port_override: ' + repr(self.port_override) + ' ' +\
 4602            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4603            'tags: ' + repr(self.tags) + ' ' +\
 4604            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4605            'username: ' + repr(self.username) + ' ' +\
 4606            '>'
 4607
 4608    def to_dict(self):
 4609        return {
 4610            'egress_filter': self.egress_filter,
 4611            'healthy': self.healthy,
 4612            'hostname': self.hostname,
 4613            'id': self.id,
 4614            'name': self.name,
 4615            'password': self.password,
 4616            'port': self.port,
 4617            'port_override': self.port_override,
 4618            'secret_store_id': self.secret_store_id,
 4619            'tags': self.tags,
 4620            'tls_required': self.tls_required,
 4621            'username': self.username,
 4622        }
 4623
 4624    @classmethod
 4625    def from_dict(cls, d):
 4626        return cls(
 4627            egress_filter=d.get('egress_filter'),
 4628            healthy=d.get('healthy'),
 4629            hostname=d.get('hostname'),
 4630            id=d.get('id'),
 4631            name=d.get('name'),
 4632            password=d.get('password'),
 4633            port=d.get('port'),
 4634            port_override=d.get('port_override'),
 4635            secret_store_id=d.get('secret_store_id'),
 4636            tags=d.get('tags'),
 4637            tls_required=d.get('tls_required'),
 4638            username=d.get('username'),
 4639        )
 4640
 4641
 4642class ElasticacheRedis:
 4643    '''
 4644
 4645    '''
 4646    __slots__ = [
 4647        'egress_filter',
 4648        'healthy',
 4649        'hostname',
 4650        'id',
 4651        'name',
 4652        'password',
 4653        'port',
 4654        'port_override',
 4655        'secret_store_id',
 4656        'tags',
 4657        'tls_required',
 4658    ]
 4659
 4660    def __init__(
 4661        self,
 4662        egress_filter=None,
 4663        healthy=None,
 4664        hostname=None,
 4665        id=None,
 4666        name=None,
 4667        password=None,
 4668        port=None,
 4669        port_override=None,
 4670        secret_store_id=None,
 4671        tags=None,
 4672        tls_required=None,
 4673    ):
 4674        self.egress_filter = egress_filter if egress_filter is not None else ''
 4675        '''
 4676         A filter applied to the routing logic to pin datasource to nodes.
 4677        '''
 4678        self.healthy = healthy if healthy is not None else False
 4679        '''
 4680         True if the datasource is reachable and the credentials are valid.
 4681        '''
 4682        self.hostname = hostname if hostname is not None else ''
 4683        '''
 4684
 4685        '''
 4686        self.id = id if id is not None else ''
 4687        '''
 4688         Unique identifier of the Resource.
 4689        '''
 4690        self.name = name if name is not None else ''
 4691        '''
 4692         Unique human-readable name of the Resource.
 4693        '''
 4694        self.password = password if password is not None else ''
 4695        '''
 4696
 4697        '''
 4698        self.port = port if port is not None else 0
 4699        '''
 4700
 4701        '''
 4702        self.port_override = port_override if port_override is not None else 0
 4703        '''
 4704
 4705        '''
 4706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4707        '''
 4708         ID of the secret store containing credentials for this resource, if any.
 4709        '''
 4710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4711        '''
 4712         Tags is a map of key, value pairs.
 4713        '''
 4714        self.tls_required = tls_required if tls_required is not None else False
 4715        '''
 4716
 4717        '''
 4718
 4719    def __repr__(self):
 4720        return '<sdm.ElasticacheRedis ' + \
 4721            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4722            'healthy: ' + repr(self.healthy) + ' ' +\
 4723            'hostname: ' + repr(self.hostname) + ' ' +\
 4724            'id: ' + repr(self.id) + ' ' +\
 4725            'name: ' + repr(self.name) + ' ' +\
 4726            'password: ' + repr(self.password) + ' ' +\
 4727            'port: ' + repr(self.port) + ' ' +\
 4728            'port_override: ' + repr(self.port_override) + ' ' +\
 4729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4730            'tags: ' + repr(self.tags) + ' ' +\
 4731            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4732            '>'
 4733
 4734    def to_dict(self):
 4735        return {
 4736            'egress_filter': self.egress_filter,
 4737            'healthy': self.healthy,
 4738            'hostname': self.hostname,
 4739            'id': self.id,
 4740            'name': self.name,
 4741            'password': self.password,
 4742            'port': self.port,
 4743            'port_override': self.port_override,
 4744            'secret_store_id': self.secret_store_id,
 4745            'tags': self.tags,
 4746            'tls_required': self.tls_required,
 4747        }
 4748
 4749    @classmethod
 4750    def from_dict(cls, d):
 4751        return cls(
 4752            egress_filter=d.get('egress_filter'),
 4753            healthy=d.get('healthy'),
 4754            hostname=d.get('hostname'),
 4755            id=d.get('id'),
 4756            name=d.get('name'),
 4757            password=d.get('password'),
 4758            port=d.get('port'),
 4759            port_override=d.get('port_override'),
 4760            secret_store_id=d.get('secret_store_id'),
 4761            tags=d.get('tags'),
 4762            tls_required=d.get('tls_required'),
 4763        )
 4764
 4765
 4766class GCP:
 4767    '''
 4768
 4769    '''
 4770    __slots__ = [
 4771        'egress_filter',
 4772        'healthy',
 4773        'id',
 4774        'keyfile',
 4775        'name',
 4776        'scopes',
 4777        'secret_store_id',
 4778        'tags',
 4779    ]
 4780
 4781    def __init__(
 4782        self,
 4783        egress_filter=None,
 4784        healthy=None,
 4785        id=None,
 4786        keyfile=None,
 4787        name=None,
 4788        scopes=None,
 4789        secret_store_id=None,
 4790        tags=None,
 4791    ):
 4792        self.egress_filter = egress_filter if egress_filter is not None else ''
 4793        '''
 4794         A filter applied to the routing logic to pin datasource to nodes.
 4795        '''
 4796        self.healthy = healthy if healthy is not None else False
 4797        '''
 4798         True if the datasource is reachable and the credentials are valid.
 4799        '''
 4800        self.id = id if id is not None else ''
 4801        '''
 4802         Unique identifier of the Resource.
 4803        '''
 4804        self.keyfile = keyfile if keyfile is not None else ''
 4805        '''
 4806
 4807        '''
 4808        self.name = name if name is not None else ''
 4809        '''
 4810         Unique human-readable name of the Resource.
 4811        '''
 4812        self.scopes = scopes if scopes is not None else ''
 4813        '''
 4814
 4815        '''
 4816        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4817        '''
 4818         ID of the secret store containing credentials for this resource, if any.
 4819        '''
 4820        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4821        '''
 4822         Tags is a map of key, value pairs.
 4823        '''
 4824
 4825    def __repr__(self):
 4826        return '<sdm.GCP ' + \
 4827            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4828            'healthy: ' + repr(self.healthy) + ' ' +\
 4829            'id: ' + repr(self.id) + ' ' +\
 4830            'keyfile: ' + repr(self.keyfile) + ' ' +\
 4831            'name: ' + repr(self.name) + ' ' +\
 4832            'scopes: ' + repr(self.scopes) + ' ' +\
 4833            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4834            'tags: ' + repr(self.tags) + ' ' +\
 4835            '>'
 4836
 4837    def to_dict(self):
 4838        return {
 4839            'egress_filter': self.egress_filter,
 4840            'healthy': self.healthy,
 4841            'id': self.id,
 4842            'keyfile': self.keyfile,
 4843            'name': self.name,
 4844            'scopes': self.scopes,
 4845            'secret_store_id': self.secret_store_id,
 4846            'tags': self.tags,
 4847        }
 4848
 4849    @classmethod
 4850    def from_dict(cls, d):
 4851        return cls(
 4852            egress_filter=d.get('egress_filter'),
 4853            healthy=d.get('healthy'),
 4854            id=d.get('id'),
 4855            keyfile=d.get('keyfile'),
 4856            name=d.get('name'),
 4857            scopes=d.get('scopes'),
 4858            secret_store_id=d.get('secret_store_id'),
 4859            tags=d.get('tags'),
 4860        )
 4861
 4862
 4863class GCPStore:
 4864    '''
 4865
 4866    '''
 4867    __slots__ = [
 4868        'id',
 4869        'name',
 4870        'projectid',
 4871        'tags',
 4872    ]
 4873
 4874    def __init__(
 4875        self,
 4876        id=None,
 4877        name=None,
 4878        projectid=None,
 4879        tags=None,
 4880    ):
 4881        self.id = id if id is not None else ''
 4882        '''
 4883         Unique identifier of the SecretStore.
 4884        '''
 4885        self.name = name if name is not None else ''
 4886        '''
 4887         Unique human-readable name of the SecretStore.
 4888        '''
 4889        self.projectid = projectid if projectid is not None else ''
 4890        '''
 4891
 4892        '''
 4893        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4894        '''
 4895         Tags is a map of key, value pairs.
 4896        '''
 4897
 4898    def __repr__(self):
 4899        return '<sdm.GCPStore ' + \
 4900            'id: ' + repr(self.id) + ' ' +\
 4901            'name: ' + repr(self.name) + ' ' +\
 4902            'projectid: ' + repr(self.projectid) + ' ' +\
 4903            'tags: ' + repr(self.tags) + ' ' +\
 4904            '>'
 4905
 4906    def to_dict(self):
 4907        return {
 4908            'id': self.id,
 4909            'name': self.name,
 4910            'projectid': self.projectid,
 4911            'tags': self.tags,
 4912        }
 4913
 4914    @classmethod
 4915    def from_dict(cls, d):
 4916        return cls(
 4917            id=d.get('id'),
 4918            name=d.get('name'),
 4919            projectid=d.get('projectid'),
 4920            tags=d.get('tags'),
 4921        )
 4922
 4923
 4924class Gateway:
 4925    '''
 4926     Gateway represents a StrongDM CLI installation running in gateway mode.
 4927    '''
 4928    __slots__ = [
 4929        'bind_address',
 4930        'gateway_filter',
 4931        'id',
 4932        'listen_address',
 4933        'name',
 4934        'state',
 4935        'tags',
 4936    ]
 4937
 4938    def __init__(
 4939        self,
 4940        bind_address=None,
 4941        gateway_filter=None,
 4942        id=None,
 4943        listen_address=None,
 4944        name=None,
 4945        state=None,
 4946        tags=None,
 4947    ):
 4948        self.bind_address = bind_address if bind_address is not None else ''
 4949        '''
 4950         The hostname/port tuple which the gateway daemon will bind to.
 4951         If not provided on create, set to "0.0.0.0:listen_address_port".
 4952        '''
 4953        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 4954        '''
 4955         GatewayFilter can be used to restrict the peering between relays and
 4956         gateways.
 4957        '''
 4958        self.id = id if id is not None else ''
 4959        '''
 4960         Unique identifier of the Gateway.
 4961        '''
 4962        self.listen_address = listen_address if listen_address is not None else ''
 4963        '''
 4964         The public hostname/port tuple at which the gateway will be accessible to clients.
 4965        '''
 4966        self.name = name if name is not None else ''
 4967        '''
 4968         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 4969        '''
 4970        self.state = state if state is not None else ''
 4971        '''
 4972         The current state of the gateway. One of: "new", "verifying_restart",
 4973         "restarting", "started", "stopped", "dead", "unknown"
 4974        '''
 4975        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4976        '''
 4977         Tags is a map of key, value pairs.
 4978        '''
 4979
 4980    def __repr__(self):
 4981        return '<sdm.Gateway ' + \
 4982            'bind_address: ' + repr(self.bind_address) + ' ' +\
 4983            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 4984            'id: ' + repr(self.id) + ' ' +\
 4985            'listen_address: ' + repr(self.listen_address) + ' ' +\
 4986            'name: ' + repr(self.name) + ' ' +\
 4987            'state: ' + repr(self.state) + ' ' +\
 4988            'tags: ' + repr(self.tags) + ' ' +\
 4989            '>'
 4990
 4991    def to_dict(self):
 4992        return {
 4993            'bind_address': self.bind_address,
 4994            'gateway_filter': self.gateway_filter,
 4995            'id': self.id,
 4996            'listen_address': self.listen_address,
 4997            'name': self.name,
 4998            'state': self.state,
 4999            'tags': self.tags,
 5000        }
 5001
 5002    @classmethod
 5003    def from_dict(cls, d):
 5004        return cls(
 5005            bind_address=d.get('bind_address'),
 5006            gateway_filter=d.get('gateway_filter'),
 5007            id=d.get('id'),
 5008            listen_address=d.get('listen_address'),
 5009            name=d.get('name'),
 5010            state=d.get('state'),
 5011            tags=d.get('tags'),
 5012        )
 5013
 5014
 5015class GetResponseMetadata:
 5016    '''
 5017     GetResponseMetadata is reserved for future use.
 5018    '''
 5019    __slots__ = []
 5020
 5021    def __init__(self, ):
 5022        pass
 5023
 5024    def __repr__(self):
 5025        return '<sdm.GetResponseMetadata ' + \
 5026            '>'
 5027
 5028    def to_dict(self):
 5029        return {}
 5030
 5031    @classmethod
 5032    def from_dict(cls, d):
 5033        return cls()
 5034
 5035
 5036class GoogleGKE:
 5037    '''
 5038
 5039    '''
 5040    __slots__ = [
 5041        'certificate_authority',
 5042        'egress_filter',
 5043        'endpoint',
 5044        'healthcheck_namespace',
 5045        'healthy',
 5046        'id',
 5047        'name',
 5048        'secret_store_id',
 5049        'service_account_key',
 5050        'tags',
 5051    ]
 5052
 5053    def __init__(
 5054        self,
 5055        certificate_authority=None,
 5056        egress_filter=None,
 5057        endpoint=None,
 5058        healthcheck_namespace=None,
 5059        healthy=None,
 5060        id=None,
 5061        name=None,
 5062        secret_store_id=None,
 5063        service_account_key=None,
 5064        tags=None,
 5065    ):
 5066        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5067        '''
 5068
 5069        '''
 5070        self.egress_filter = egress_filter if egress_filter is not None else ''
 5071        '''
 5072         A filter applied to the routing logic to pin datasource to nodes.
 5073        '''
 5074        self.endpoint = endpoint if endpoint is not None else ''
 5075        '''
 5076
 5077        '''
 5078        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5079        '''
 5080         The path used to check the health of your connection.  Defaults to `default`.
 5081        '''
 5082        self.healthy = healthy if healthy is not None else False
 5083        '''
 5084         True if the datasource is reachable and the credentials are valid.
 5085        '''
 5086        self.id = id if id is not None else ''
 5087        '''
 5088         Unique identifier of the Resource.
 5089        '''
 5090        self.name = name if name is not None else ''
 5091        '''
 5092         Unique human-readable name of the Resource.
 5093        '''
 5094        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5095        '''
 5096         ID of the secret store containing credentials for this resource, if any.
 5097        '''
 5098        self.service_account_key = service_account_key if service_account_key is not None else ''
 5099        '''
 5100
 5101        '''
 5102        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5103        '''
 5104         Tags is a map of key, value pairs.
 5105        '''
 5106
 5107    def __repr__(self):
 5108        return '<sdm.GoogleGKE ' + \
 5109            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5110            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5111            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5112            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5113            'healthy: ' + repr(self.healthy) + ' ' +\
 5114            'id: ' + repr(self.id) + ' ' +\
 5115            'name: ' + repr(self.name) + ' ' +\
 5116            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5117            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5118            'tags: ' + repr(self.tags) + ' ' +\
 5119            '>'
 5120
 5121    def to_dict(self):
 5122        return {
 5123            'certificate_authority': self.certificate_authority,
 5124            'egress_filter': self.egress_filter,
 5125            'endpoint': self.endpoint,
 5126            'healthcheck_namespace': self.healthcheck_namespace,
 5127            'healthy': self.healthy,
 5128            'id': self.id,
 5129            'name': self.name,
 5130            'secret_store_id': self.secret_store_id,
 5131            'service_account_key': self.service_account_key,
 5132            'tags': self.tags,
 5133        }
 5134
 5135    @classmethod
 5136    def from_dict(cls, d):
 5137        return cls(
 5138            certificate_authority=d.get('certificate_authority'),
 5139            egress_filter=d.get('egress_filter'),
 5140            endpoint=d.get('endpoint'),
 5141            healthcheck_namespace=d.get('healthcheck_namespace'),
 5142            healthy=d.get('healthy'),
 5143            id=d.get('id'),
 5144            name=d.get('name'),
 5145            secret_store_id=d.get('secret_store_id'),
 5146            service_account_key=d.get('service_account_key'),
 5147            tags=d.get('tags'),
 5148        )
 5149
 5150
 5151class GoogleGKEUserImpersonation:
 5152    '''
 5153
 5154    '''
 5155    __slots__ = [
 5156        'certificate_authority',
 5157        'egress_filter',
 5158        'endpoint',
 5159        'healthcheck_namespace',
 5160        'healthy',
 5161        'id',
 5162        'name',
 5163        'secret_store_id',
 5164        'service_account_key',
 5165        'tags',
 5166    ]
 5167
 5168    def __init__(
 5169        self,
 5170        certificate_authority=None,
 5171        egress_filter=None,
 5172        endpoint=None,
 5173        healthcheck_namespace=None,
 5174        healthy=None,
 5175        id=None,
 5176        name=None,
 5177        secret_store_id=None,
 5178        service_account_key=None,
 5179        tags=None,
 5180    ):
 5181        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5182        '''
 5183
 5184        '''
 5185        self.egress_filter = egress_filter if egress_filter is not None else ''
 5186        '''
 5187         A filter applied to the routing logic to pin datasource to nodes.
 5188        '''
 5189        self.endpoint = endpoint if endpoint is not None else ''
 5190        '''
 5191
 5192        '''
 5193        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5194        '''
 5195         The path used to check the health of your connection.  Defaults to `default`.
 5196        '''
 5197        self.healthy = healthy if healthy is not None else False
 5198        '''
 5199         True if the datasource is reachable and the credentials are valid.
 5200        '''
 5201        self.id = id if id is not None else ''
 5202        '''
 5203         Unique identifier of the Resource.
 5204        '''
 5205        self.name = name if name is not None else ''
 5206        '''
 5207         Unique human-readable name of the Resource.
 5208        '''
 5209        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5210        '''
 5211         ID of the secret store containing credentials for this resource, if any.
 5212        '''
 5213        self.service_account_key = service_account_key if service_account_key is not None else ''
 5214        '''
 5215
 5216        '''
 5217        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5218        '''
 5219         Tags is a map of key, value pairs.
 5220        '''
 5221
 5222    def __repr__(self):
 5223        return '<sdm.GoogleGKEUserImpersonation ' + \
 5224            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5225            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5226            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5227            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5228            'healthy: ' + repr(self.healthy) + ' ' +\
 5229            'id: ' + repr(self.id) + ' ' +\
 5230            'name: ' + repr(self.name) + ' ' +\
 5231            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5232            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5233            'tags: ' + repr(self.tags) + ' ' +\
 5234            '>'
 5235
 5236    def to_dict(self):
 5237        return {
 5238            'certificate_authority': self.certificate_authority,
 5239            'egress_filter': self.egress_filter,
 5240            'endpoint': self.endpoint,
 5241            'healthcheck_namespace': self.healthcheck_namespace,
 5242            'healthy': self.healthy,
 5243            'id': self.id,
 5244            'name': self.name,
 5245            'secret_store_id': self.secret_store_id,
 5246            'service_account_key': self.service_account_key,
 5247            'tags': self.tags,
 5248        }
 5249
 5250    @classmethod
 5251    def from_dict(cls, d):
 5252        return cls(
 5253            certificate_authority=d.get('certificate_authority'),
 5254            egress_filter=d.get('egress_filter'),
 5255            endpoint=d.get('endpoint'),
 5256            healthcheck_namespace=d.get('healthcheck_namespace'),
 5257            healthy=d.get('healthy'),
 5258            id=d.get('id'),
 5259            name=d.get('name'),
 5260            secret_store_id=d.get('secret_store_id'),
 5261            service_account_key=d.get('service_account_key'),
 5262            tags=d.get('tags'),
 5263        )
 5264
 5265
 5266class Greenplum:
 5267    '''
 5268
 5269    '''
 5270    __slots__ = [
 5271        'database',
 5272        'egress_filter',
 5273        'healthy',
 5274        'hostname',
 5275        'id',
 5276        'name',
 5277        'override_database',
 5278        'password',
 5279        'port',
 5280        'port_override',
 5281        'secret_store_id',
 5282        'tags',
 5283        'username',
 5284    ]
 5285
 5286    def __init__(
 5287        self,
 5288        database=None,
 5289        egress_filter=None,
 5290        healthy=None,
 5291        hostname=None,
 5292        id=None,
 5293        name=None,
 5294        override_database=None,
 5295        password=None,
 5296        port=None,
 5297        port_override=None,
 5298        secret_store_id=None,
 5299        tags=None,
 5300        username=None,
 5301    ):
 5302        self.database = database if database is not None else ''
 5303        '''
 5304
 5305        '''
 5306        self.egress_filter = egress_filter if egress_filter is not None else ''
 5307        '''
 5308         A filter applied to the routing logic to pin datasource to nodes.
 5309        '''
 5310        self.healthy = healthy if healthy is not None else False
 5311        '''
 5312         True if the datasource is reachable and the credentials are valid.
 5313        '''
 5314        self.hostname = hostname if hostname is not None else ''
 5315        '''
 5316
 5317        '''
 5318        self.id = id if id is not None else ''
 5319        '''
 5320         Unique identifier of the Resource.
 5321        '''
 5322        self.name = name if name is not None else ''
 5323        '''
 5324         Unique human-readable name of the Resource.
 5325        '''
 5326        self.override_database = override_database if override_database is not None else False
 5327        '''
 5328
 5329        '''
 5330        self.password = password if password is not None else ''
 5331        '''
 5332
 5333        '''
 5334        self.port = port if port is not None else 0
 5335        '''
 5336
 5337        '''
 5338        self.port_override = port_override if port_override is not None else 0
 5339        '''
 5340
 5341        '''
 5342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5343        '''
 5344         ID of the secret store containing credentials for this resource, if any.
 5345        '''
 5346        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5347        '''
 5348         Tags is a map of key, value pairs.
 5349        '''
 5350        self.username = username if username is not None else ''
 5351        '''
 5352
 5353        '''
 5354
 5355    def __repr__(self):
 5356        return '<sdm.Greenplum ' + \
 5357            'database: ' + repr(self.database) + ' ' +\
 5358            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5359            'healthy: ' + repr(self.healthy) + ' ' +\
 5360            'hostname: ' + repr(self.hostname) + ' ' +\
 5361            'id: ' + repr(self.id) + ' ' +\
 5362            'name: ' + repr(self.name) + ' ' +\
 5363            'override_database: ' + repr(self.override_database) + ' ' +\
 5364            'password: ' + repr(self.password) + ' ' +\
 5365            'port: ' + repr(self.port) + ' ' +\
 5366            'port_override: ' + repr(self.port_override) + ' ' +\
 5367            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5368            'tags: ' + repr(self.tags) + ' ' +\
 5369            'username: ' + repr(self.username) + ' ' +\
 5370            '>'
 5371
 5372    def to_dict(self):
 5373        return {
 5374            'database': self.database,
 5375            'egress_filter': self.egress_filter,
 5376            'healthy': self.healthy,
 5377            'hostname': self.hostname,
 5378            'id': self.id,
 5379            'name': self.name,
 5380            'override_database': self.override_database,
 5381            'password': self.password,
 5382            'port': self.port,
 5383            'port_override': self.port_override,
 5384            'secret_store_id': self.secret_store_id,
 5385            'tags': self.tags,
 5386            'username': self.username,
 5387        }
 5388
 5389    @classmethod
 5390    def from_dict(cls, d):
 5391        return cls(
 5392            database=d.get('database'),
 5393            egress_filter=d.get('egress_filter'),
 5394            healthy=d.get('healthy'),
 5395            hostname=d.get('hostname'),
 5396            id=d.get('id'),
 5397            name=d.get('name'),
 5398            override_database=d.get('override_database'),
 5399            password=d.get('password'),
 5400            port=d.get('port'),
 5401            port_override=d.get('port_override'),
 5402            secret_store_id=d.get('secret_store_id'),
 5403            tags=d.get('tags'),
 5404            username=d.get('username'),
 5405        )
 5406
 5407
 5408class HTTPAuth:
 5409    '''
 5410
 5411    '''
 5412    __slots__ = [
 5413        'auth_header',
 5414        'default_path',
 5415        'egress_filter',
 5416        'headers_blacklist',
 5417        'healthcheck_path',
 5418        'healthy',
 5419        'id',
 5420        'name',
 5421        'secret_store_id',
 5422        'subdomain',
 5423        'tags',
 5424        'url',
 5425    ]
 5426
 5427    def __init__(
 5428        self,
 5429        auth_header=None,
 5430        default_path=None,
 5431        egress_filter=None,
 5432        headers_blacklist=None,
 5433        healthcheck_path=None,
 5434        healthy=None,
 5435        id=None,
 5436        name=None,
 5437        secret_store_id=None,
 5438        subdomain=None,
 5439        tags=None,
 5440        url=None,
 5441    ):
 5442        self.auth_header = auth_header if auth_header is not None else ''
 5443        '''
 5444
 5445        '''
 5446        self.default_path = default_path if default_path is not None else ''
 5447        '''
 5448
 5449        '''
 5450        self.egress_filter = egress_filter if egress_filter is not None else ''
 5451        '''
 5452         A filter applied to the routing logic to pin datasource to nodes.
 5453        '''
 5454        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5455        '''
 5456
 5457        '''
 5458        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5459        '''
 5460
 5461        '''
 5462        self.healthy = healthy if healthy is not None else False
 5463        '''
 5464         True if the datasource is reachable and the credentials are valid.
 5465        '''
 5466        self.id = id if id is not None else ''
 5467        '''
 5468         Unique identifier of the Resource.
 5469        '''
 5470        self.name = name if name is not None else ''
 5471        '''
 5472         Unique human-readable name of the Resource.
 5473        '''
 5474        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5475        '''
 5476         ID of the secret store containing credentials for this resource, if any.
 5477        '''
 5478        self.subdomain = subdomain if subdomain is not None else ''
 5479        '''
 5480
 5481        '''
 5482        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5483        '''
 5484         Tags is a map of key, value pairs.
 5485        '''
 5486        self.url = url if url is not None else ''
 5487        '''
 5488
 5489        '''
 5490
 5491    def __repr__(self):
 5492        return '<sdm.HTTPAuth ' + \
 5493            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5494            'default_path: ' + repr(self.default_path) + ' ' +\
 5495            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5496            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5497            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5498            'healthy: ' + repr(self.healthy) + ' ' +\
 5499            'id: ' + repr(self.id) + ' ' +\
 5500            'name: ' + repr(self.name) + ' ' +\
 5501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5502            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5503            'tags: ' + repr(self.tags) + ' ' +\
 5504            'url: ' + repr(self.url) + ' ' +\
 5505            '>'
 5506
 5507    def to_dict(self):
 5508        return {
 5509            'auth_header': self.auth_header,
 5510            'default_path': self.default_path,
 5511            'egress_filter': self.egress_filter,
 5512            'headers_blacklist': self.headers_blacklist,
 5513            'healthcheck_path': self.healthcheck_path,
 5514            'healthy': self.healthy,
 5515            'id': self.id,
 5516            'name': self.name,
 5517            'secret_store_id': self.secret_store_id,
 5518            'subdomain': self.subdomain,
 5519            'tags': self.tags,
 5520            'url': self.url,
 5521        }
 5522
 5523    @classmethod
 5524    def from_dict(cls, d):
 5525        return cls(
 5526            auth_header=d.get('auth_header'),
 5527            default_path=d.get('default_path'),
 5528            egress_filter=d.get('egress_filter'),
 5529            headers_blacklist=d.get('headers_blacklist'),
 5530            healthcheck_path=d.get('healthcheck_path'),
 5531            healthy=d.get('healthy'),
 5532            id=d.get('id'),
 5533            name=d.get('name'),
 5534            secret_store_id=d.get('secret_store_id'),
 5535            subdomain=d.get('subdomain'),
 5536            tags=d.get('tags'),
 5537            url=d.get('url'),
 5538        )
 5539
 5540
 5541class HTTPBasicAuth:
 5542    '''
 5543
 5544    '''
 5545    __slots__ = [
 5546        'default_path',
 5547        'egress_filter',
 5548        'headers_blacklist',
 5549        'healthcheck_path',
 5550        'healthy',
 5551        'id',
 5552        'name',
 5553        'password',
 5554        'secret_store_id',
 5555        'subdomain',
 5556        'tags',
 5557        'url',
 5558        'username',
 5559    ]
 5560
 5561    def __init__(
 5562        self,
 5563        default_path=None,
 5564        egress_filter=None,
 5565        headers_blacklist=None,
 5566        healthcheck_path=None,
 5567        healthy=None,
 5568        id=None,
 5569        name=None,
 5570        password=None,
 5571        secret_store_id=None,
 5572        subdomain=None,
 5573        tags=None,
 5574        url=None,
 5575        username=None,
 5576    ):
 5577        self.default_path = default_path if default_path is not None else ''
 5578        '''
 5579
 5580        '''
 5581        self.egress_filter = egress_filter if egress_filter is not None else ''
 5582        '''
 5583         A filter applied to the routing logic to pin datasource to nodes.
 5584        '''
 5585        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5586        '''
 5587
 5588        '''
 5589        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5590        '''
 5591
 5592        '''
 5593        self.healthy = healthy if healthy is not None else False
 5594        '''
 5595         True if the datasource is reachable and the credentials are valid.
 5596        '''
 5597        self.id = id if id is not None else ''
 5598        '''
 5599         Unique identifier of the Resource.
 5600        '''
 5601        self.name = name if name is not None else ''
 5602        '''
 5603         Unique human-readable name of the Resource.
 5604        '''
 5605        self.password = password if password is not None else ''
 5606        '''
 5607
 5608        '''
 5609        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5610        '''
 5611         ID of the secret store containing credentials for this resource, if any.
 5612        '''
 5613        self.subdomain = subdomain if subdomain is not None else ''
 5614        '''
 5615
 5616        '''
 5617        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5618        '''
 5619         Tags is a map of key, value pairs.
 5620        '''
 5621        self.url = url if url is not None else ''
 5622        '''
 5623
 5624        '''
 5625        self.username = username if username is not None else ''
 5626        '''
 5627
 5628        '''
 5629
 5630    def __repr__(self):
 5631        return '<sdm.HTTPBasicAuth ' + \
 5632            'default_path: ' + repr(self.default_path) + ' ' +\
 5633            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5634            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5635            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5636            'healthy: ' + repr(self.healthy) + ' ' +\
 5637            'id: ' + repr(self.id) + ' ' +\
 5638            'name: ' + repr(self.name) + ' ' +\
 5639            'password: ' + repr(self.password) + ' ' +\
 5640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5641            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5642            'tags: ' + repr(self.tags) + ' ' +\
 5643            'url: ' + repr(self.url) + ' ' +\
 5644            'username: ' + repr(self.username) + ' ' +\
 5645            '>'
 5646
 5647    def to_dict(self):
 5648        return {
 5649            'default_path': self.default_path,
 5650            'egress_filter': self.egress_filter,
 5651            'headers_blacklist': self.headers_blacklist,
 5652            'healthcheck_path': self.healthcheck_path,
 5653            'healthy': self.healthy,
 5654            'id': self.id,
 5655            'name': self.name,
 5656            'password': self.password,
 5657            'secret_store_id': self.secret_store_id,
 5658            'subdomain': self.subdomain,
 5659            'tags': self.tags,
 5660            'url': self.url,
 5661            'username': self.username,
 5662        }
 5663
 5664    @classmethod
 5665    def from_dict(cls, d):
 5666        return cls(
 5667            default_path=d.get('default_path'),
 5668            egress_filter=d.get('egress_filter'),
 5669            headers_blacklist=d.get('headers_blacklist'),
 5670            healthcheck_path=d.get('healthcheck_path'),
 5671            healthy=d.get('healthy'),
 5672            id=d.get('id'),
 5673            name=d.get('name'),
 5674            password=d.get('password'),
 5675            secret_store_id=d.get('secret_store_id'),
 5676            subdomain=d.get('subdomain'),
 5677            tags=d.get('tags'),
 5678            url=d.get('url'),
 5679            username=d.get('username'),
 5680        )
 5681
 5682
 5683class HTTPNoAuth:
 5684    '''
 5685
 5686    '''
 5687    __slots__ = [
 5688        'default_path',
 5689        'egress_filter',
 5690        'headers_blacklist',
 5691        'healthcheck_path',
 5692        'healthy',
 5693        'id',
 5694        'name',
 5695        'secret_store_id',
 5696        'subdomain',
 5697        'tags',
 5698        'url',
 5699    ]
 5700
 5701    def __init__(
 5702        self,
 5703        default_path=None,
 5704        egress_filter=None,
 5705        headers_blacklist=None,
 5706        healthcheck_path=None,
 5707        healthy=None,
 5708        id=None,
 5709        name=None,
 5710        secret_store_id=None,
 5711        subdomain=None,
 5712        tags=None,
 5713        url=None,
 5714    ):
 5715        self.default_path = default_path if default_path is not None else ''
 5716        '''
 5717
 5718        '''
 5719        self.egress_filter = egress_filter if egress_filter is not None else ''
 5720        '''
 5721         A filter applied to the routing logic to pin datasource to nodes.
 5722        '''
 5723        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5724        '''
 5725
 5726        '''
 5727        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5728        '''
 5729
 5730        '''
 5731        self.healthy = healthy if healthy is not None else False
 5732        '''
 5733         True if the datasource is reachable and the credentials are valid.
 5734        '''
 5735        self.id = id if id is not None else ''
 5736        '''
 5737         Unique identifier of the Resource.
 5738        '''
 5739        self.name = name if name is not None else ''
 5740        '''
 5741         Unique human-readable name of the Resource.
 5742        '''
 5743        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5744        '''
 5745         ID of the secret store containing credentials for this resource, if any.
 5746        '''
 5747        self.subdomain = subdomain if subdomain is not None else ''
 5748        '''
 5749
 5750        '''
 5751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5752        '''
 5753         Tags is a map of key, value pairs.
 5754        '''
 5755        self.url = url if url is not None else ''
 5756        '''
 5757
 5758        '''
 5759
 5760    def __repr__(self):
 5761        return '<sdm.HTTPNoAuth ' + \
 5762            'default_path: ' + repr(self.default_path) + ' ' +\
 5763            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5764            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5765            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5766            'healthy: ' + repr(self.healthy) + ' ' +\
 5767            'id: ' + repr(self.id) + ' ' +\
 5768            'name: ' + repr(self.name) + ' ' +\
 5769            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5770            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5771            'tags: ' + repr(self.tags) + ' ' +\
 5772            'url: ' + repr(self.url) + ' ' +\
 5773            '>'
 5774
 5775    def to_dict(self):
 5776        return {
 5777            'default_path': self.default_path,
 5778            'egress_filter': self.egress_filter,
 5779            'headers_blacklist': self.headers_blacklist,
 5780            'healthcheck_path': self.healthcheck_path,
 5781            'healthy': self.healthy,
 5782            'id': self.id,
 5783            'name': self.name,
 5784            'secret_store_id': self.secret_store_id,
 5785            'subdomain': self.subdomain,
 5786            'tags': self.tags,
 5787            'url': self.url,
 5788        }
 5789
 5790    @classmethod
 5791    def from_dict(cls, d):
 5792        return cls(
 5793            default_path=d.get('default_path'),
 5794            egress_filter=d.get('egress_filter'),
 5795            headers_blacklist=d.get('headers_blacklist'),
 5796            healthcheck_path=d.get('healthcheck_path'),
 5797            healthy=d.get('healthy'),
 5798            id=d.get('id'),
 5799            name=d.get('name'),
 5800            secret_store_id=d.get('secret_store_id'),
 5801            subdomain=d.get('subdomain'),
 5802            tags=d.get('tags'),
 5803            url=d.get('url'),
 5804        )
 5805
 5806
 5807class Kubernetes:
 5808    '''
 5809
 5810    '''
 5811    __slots__ = [
 5812        'certificate_authority',
 5813        'client_certificate',
 5814        'client_key',
 5815        'egress_filter',
 5816        'healthcheck_namespace',
 5817        'healthy',
 5818        'hostname',
 5819        'id',
 5820        'name',
 5821        'port',
 5822        'secret_store_id',
 5823        'tags',
 5824    ]
 5825
 5826    def __init__(
 5827        self,
 5828        certificate_authority=None,
 5829        client_certificate=None,
 5830        client_key=None,
 5831        egress_filter=None,
 5832        healthcheck_namespace=None,
 5833        healthy=None,
 5834        hostname=None,
 5835        id=None,
 5836        name=None,
 5837        port=None,
 5838        secret_store_id=None,
 5839        tags=None,
 5840    ):
 5841        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5842        '''
 5843
 5844        '''
 5845        self.client_certificate = client_certificate if client_certificate is not None else ''
 5846        '''
 5847
 5848        '''
 5849        self.client_key = client_key if client_key is not None else ''
 5850        '''
 5851
 5852        '''
 5853        self.egress_filter = egress_filter if egress_filter is not None else ''
 5854        '''
 5855         A filter applied to the routing logic to pin datasource to nodes.
 5856        '''
 5857        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5858        '''
 5859         The path used to check the health of your connection.  Defaults to `default`.
 5860        '''
 5861        self.healthy = healthy if healthy is not None else False
 5862        '''
 5863         True if the datasource is reachable and the credentials are valid.
 5864        '''
 5865        self.hostname = hostname if hostname is not None else ''
 5866        '''
 5867
 5868        '''
 5869        self.id = id if id is not None else ''
 5870        '''
 5871         Unique identifier of the Resource.
 5872        '''
 5873        self.name = name if name is not None else ''
 5874        '''
 5875         Unique human-readable name of the Resource.
 5876        '''
 5877        self.port = port if port is not None else 0
 5878        '''
 5879
 5880        '''
 5881        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5882        '''
 5883         ID of the secret store containing credentials for this resource, if any.
 5884        '''
 5885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5886        '''
 5887         Tags is a map of key, value pairs.
 5888        '''
 5889
 5890    def __repr__(self):
 5891        return '<sdm.Kubernetes ' + \
 5892            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5893            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 5894            'client_key: ' + repr(self.client_key) + ' ' +\
 5895            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5896            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5897            'healthy: ' + repr(self.healthy) + ' ' +\
 5898            'hostname: ' + repr(self.hostname) + ' ' +\
 5899            'id: ' + repr(self.id) + ' ' +\
 5900            'name: ' + repr(self.name) + ' ' +\
 5901            'port: ' + repr(self.port) + ' ' +\
 5902            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5903            'tags: ' + repr(self.tags) + ' ' +\
 5904            '>'
 5905
 5906    def to_dict(self):
 5907        return {
 5908            'certificate_authority': self.certificate_authority,
 5909            'client_certificate': self.client_certificate,
 5910            'client_key': self.client_key,
 5911            'egress_filter': self.egress_filter,
 5912            'healthcheck_namespace': self.healthcheck_namespace,
 5913            'healthy': self.healthy,
 5914            'hostname': self.hostname,
 5915            'id': self.id,
 5916            'name': self.name,
 5917            'port': self.port,
 5918            'secret_store_id': self.secret_store_id,
 5919            'tags': self.tags,
 5920        }
 5921
 5922    @classmethod
 5923    def from_dict(cls, d):
 5924        return cls(
 5925            certificate_authority=d.get('certificate_authority'),
 5926            client_certificate=d.get('client_certificate'),
 5927            client_key=d.get('client_key'),
 5928            egress_filter=d.get('egress_filter'),
 5929            healthcheck_namespace=d.get('healthcheck_namespace'),
 5930            healthy=d.get('healthy'),
 5931            hostname=d.get('hostname'),
 5932            id=d.get('id'),
 5933            name=d.get('name'),
 5934            port=d.get('port'),
 5935            secret_store_id=d.get('secret_store_id'),
 5936            tags=d.get('tags'),
 5937        )
 5938
 5939
 5940class KubernetesBasicAuth:
 5941    '''
 5942
 5943    '''
 5944    __slots__ = [
 5945        'egress_filter',
 5946        'healthcheck_namespace',
 5947        'healthy',
 5948        'hostname',
 5949        'id',
 5950        'name',
 5951        'password',
 5952        'port',
 5953        'secret_store_id',
 5954        'tags',
 5955        'username',
 5956    ]
 5957
 5958    def __init__(
 5959        self,
 5960        egress_filter=None,
 5961        healthcheck_namespace=None,
 5962        healthy=None,
 5963        hostname=None,
 5964        id=None,
 5965        name=None,
 5966        password=None,
 5967        port=None,
 5968        secret_store_id=None,
 5969        tags=None,
 5970        username=None,
 5971    ):
 5972        self.egress_filter = egress_filter if egress_filter is not None else ''
 5973        '''
 5974         A filter applied to the routing logic to pin datasource to nodes.
 5975        '''
 5976        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5977        '''
 5978         The path used to check the health of your connection.  Defaults to `default`.
 5979        '''
 5980        self.healthy = healthy if healthy is not None else False
 5981        '''
 5982         True if the datasource is reachable and the credentials are valid.
 5983        '''
 5984        self.hostname = hostname if hostname is not None else ''
 5985        '''
 5986
 5987        '''
 5988        self.id = id if id is not None else ''
 5989        '''
 5990         Unique identifier of the Resource.
 5991        '''
 5992        self.name = name if name is not None else ''
 5993        '''
 5994         Unique human-readable name of the Resource.
 5995        '''
 5996        self.password = password if password is not None else ''
 5997        '''
 5998
 5999        '''
 6000        self.port = port if port is not None else 0
 6001        '''
 6002
 6003        '''
 6004        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6005        '''
 6006         ID of the secret store containing credentials for this resource, if any.
 6007        '''
 6008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6009        '''
 6010         Tags is a map of key, value pairs.
 6011        '''
 6012        self.username = username if username is not None else ''
 6013        '''
 6014
 6015        '''
 6016
 6017    def __repr__(self):
 6018        return '<sdm.KubernetesBasicAuth ' + \
 6019            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6020            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6021            'healthy: ' + repr(self.healthy) + ' ' +\
 6022            'hostname: ' + repr(self.hostname) + ' ' +\
 6023            'id: ' + repr(self.id) + ' ' +\
 6024            'name: ' + repr(self.name) + ' ' +\
 6025            'password: ' + repr(self.password) + ' ' +\
 6026            'port: ' + repr(self.port) + ' ' +\
 6027            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6028            'tags: ' + repr(self.tags) + ' ' +\
 6029            'username: ' + repr(self.username) + ' ' +\
 6030            '>'
 6031
 6032    def to_dict(self):
 6033        return {
 6034            'egress_filter': self.egress_filter,
 6035            'healthcheck_namespace': self.healthcheck_namespace,
 6036            'healthy': self.healthy,
 6037            'hostname': self.hostname,
 6038            'id': self.id,
 6039            'name': self.name,
 6040            'password': self.password,
 6041            'port': self.port,
 6042            'secret_store_id': self.secret_store_id,
 6043            'tags': self.tags,
 6044            'username': self.username,
 6045        }
 6046
 6047    @classmethod
 6048    def from_dict(cls, d):
 6049        return cls(
 6050            egress_filter=d.get('egress_filter'),
 6051            healthcheck_namespace=d.get('healthcheck_namespace'),
 6052            healthy=d.get('healthy'),
 6053            hostname=d.get('hostname'),
 6054            id=d.get('id'),
 6055            name=d.get('name'),
 6056            password=d.get('password'),
 6057            port=d.get('port'),
 6058            secret_store_id=d.get('secret_store_id'),
 6059            tags=d.get('tags'),
 6060            username=d.get('username'),
 6061        )
 6062
 6063
 6064class KubernetesServiceAccount:
 6065    '''
 6066
 6067    '''
 6068    __slots__ = [
 6069        'egress_filter',
 6070        'healthcheck_namespace',
 6071        'healthy',
 6072        'hostname',
 6073        'id',
 6074        'name',
 6075        'port',
 6076        'secret_store_id',
 6077        'tags',
 6078        'token',
 6079    ]
 6080
 6081    def __init__(
 6082        self,
 6083        egress_filter=None,
 6084        healthcheck_namespace=None,
 6085        healthy=None,
 6086        hostname=None,
 6087        id=None,
 6088        name=None,
 6089        port=None,
 6090        secret_store_id=None,
 6091        tags=None,
 6092        token=None,
 6093    ):
 6094        self.egress_filter = egress_filter if egress_filter is not None else ''
 6095        '''
 6096         A filter applied to the routing logic to pin datasource to nodes.
 6097        '''
 6098        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6099        '''
 6100         The path used to check the health of your connection.  Defaults to `default`.
 6101        '''
 6102        self.healthy = healthy if healthy is not None else False
 6103        '''
 6104         True if the datasource is reachable and the credentials are valid.
 6105        '''
 6106        self.hostname = hostname if hostname is not None else ''
 6107        '''
 6108
 6109        '''
 6110        self.id = id if id is not None else ''
 6111        '''
 6112         Unique identifier of the Resource.
 6113        '''
 6114        self.name = name if name is not None else ''
 6115        '''
 6116         Unique human-readable name of the Resource.
 6117        '''
 6118        self.port = port if port is not None else 0
 6119        '''
 6120
 6121        '''
 6122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6123        '''
 6124         ID of the secret store containing credentials for this resource, if any.
 6125        '''
 6126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6127        '''
 6128         Tags is a map of key, value pairs.
 6129        '''
 6130        self.token = token if token is not None else ''
 6131        '''
 6132
 6133        '''
 6134
 6135    def __repr__(self):
 6136        return '<sdm.KubernetesServiceAccount ' + \
 6137            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6138            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6139            'healthy: ' + repr(self.healthy) + ' ' +\
 6140            'hostname: ' + repr(self.hostname) + ' ' +\
 6141            'id: ' + repr(self.id) + ' ' +\
 6142            'name: ' + repr(self.name) + ' ' +\
 6143            'port: ' + repr(self.port) + ' ' +\
 6144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6145            'tags: ' + repr(self.tags) + ' ' +\
 6146            'token: ' + repr(self.token) + ' ' +\
 6147            '>'
 6148
 6149    def to_dict(self):
 6150        return {
 6151            'egress_filter': self.egress_filter,
 6152            'healthcheck_namespace': self.healthcheck_namespace,
 6153            'healthy': self.healthy,
 6154            'hostname': self.hostname,
 6155            'id': self.id,
 6156            'name': self.name,
 6157            'port': self.port,
 6158            'secret_store_id': self.secret_store_id,
 6159            'tags': self.tags,
 6160            'token': self.token,
 6161        }
 6162
 6163    @classmethod
 6164    def from_dict(cls, d):
 6165        return cls(
 6166            egress_filter=d.get('egress_filter'),
 6167            healthcheck_namespace=d.get('healthcheck_namespace'),
 6168            healthy=d.get('healthy'),
 6169            hostname=d.get('hostname'),
 6170            id=d.get('id'),
 6171            name=d.get('name'),
 6172            port=d.get('port'),
 6173            secret_store_id=d.get('secret_store_id'),
 6174            tags=d.get('tags'),
 6175            token=d.get('token'),
 6176        )
 6177
 6178
 6179class KubernetesServiceAccountUserImpersonation:
 6180    '''
 6181
 6182    '''
 6183    __slots__ = [
 6184        'egress_filter',
 6185        'healthcheck_namespace',
 6186        'healthy',
 6187        'hostname',
 6188        'id',
 6189        'name',
 6190        'port',
 6191        'secret_store_id',
 6192        'tags',
 6193        'token',
 6194    ]
 6195
 6196    def __init__(
 6197        self,
 6198        egress_filter=None,
 6199        healthcheck_namespace=None,
 6200        healthy=None,
 6201        hostname=None,
 6202        id=None,
 6203        name=None,
 6204        port=None,
 6205        secret_store_id=None,
 6206        tags=None,
 6207        token=None,
 6208    ):
 6209        self.egress_filter = egress_filter if egress_filter is not None else ''
 6210        '''
 6211         A filter applied to the routing logic to pin datasource to nodes.
 6212        '''
 6213        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6214        '''
 6215         The path used to check the health of your connection.  Defaults to `default`.
 6216        '''
 6217        self.healthy = healthy if healthy is not None else False
 6218        '''
 6219         True if the datasource is reachable and the credentials are valid.
 6220        '''
 6221        self.hostname = hostname if hostname is not None else ''
 6222        '''
 6223
 6224        '''
 6225        self.id = id if id is not None else ''
 6226        '''
 6227         Unique identifier of the Resource.
 6228        '''
 6229        self.name = name if name is not None else ''
 6230        '''
 6231         Unique human-readable name of the Resource.
 6232        '''
 6233        self.port = port if port is not None else 0
 6234        '''
 6235
 6236        '''
 6237        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6238        '''
 6239         ID of the secret store containing credentials for this resource, if any.
 6240        '''
 6241        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6242        '''
 6243         Tags is a map of key, value pairs.
 6244        '''
 6245        self.token = token if token is not None else ''
 6246        '''
 6247
 6248        '''
 6249
 6250    def __repr__(self):
 6251        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6252            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6253            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6254            'healthy: ' + repr(self.healthy) + ' ' +\
 6255            'hostname: ' + repr(self.hostname) + ' ' +\
 6256            'id: ' + repr(self.id) + ' ' +\
 6257            'name: ' + repr(self.name) + ' ' +\
 6258            'port: ' + repr(self.port) + ' ' +\
 6259            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6260            'tags: ' + repr(self.tags) + ' ' +\
 6261            'token: ' + repr(self.token) + ' ' +\
 6262            '>'
 6263
 6264    def to_dict(self):
 6265        return {
 6266            'egress_filter': self.egress_filter,
 6267            'healthcheck_namespace': self.healthcheck_namespace,
 6268            'healthy': self.healthy,
 6269            'hostname': self.hostname,
 6270            'id': self.id,
 6271            'name': self.name,
 6272            'port': self.port,
 6273            'secret_store_id': self.secret_store_id,
 6274            'tags': self.tags,
 6275            'token': self.token,
 6276        }
 6277
 6278    @classmethod
 6279    def from_dict(cls, d):
 6280        return cls(
 6281            egress_filter=d.get('egress_filter'),
 6282            healthcheck_namespace=d.get('healthcheck_namespace'),
 6283            healthy=d.get('healthy'),
 6284            hostname=d.get('hostname'),
 6285            id=d.get('id'),
 6286            name=d.get('name'),
 6287            port=d.get('port'),
 6288            secret_store_id=d.get('secret_store_id'),
 6289            tags=d.get('tags'),
 6290            token=d.get('token'),
 6291        )
 6292
 6293
 6294class KubernetesUserImpersonation:
 6295    '''
 6296
 6297    '''
 6298    __slots__ = [
 6299        'certificate_authority',
 6300        'client_certificate',
 6301        'client_key',
 6302        'egress_filter',
 6303        'healthcheck_namespace',
 6304        'healthy',
 6305        'hostname',
 6306        'id',
 6307        'name',
 6308        'port',
 6309        'secret_store_id',
 6310        'tags',
 6311    ]
 6312
 6313    def __init__(
 6314        self,
 6315        certificate_authority=None,
 6316        client_certificate=None,
 6317        client_key=None,
 6318        egress_filter=None,
 6319        healthcheck_namespace=None,
 6320        healthy=None,
 6321        hostname=None,
 6322        id=None,
 6323        name=None,
 6324        port=None,
 6325        secret_store_id=None,
 6326        tags=None,
 6327    ):
 6328        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6329        '''
 6330
 6331        '''
 6332        self.client_certificate = client_certificate if client_certificate is not None else ''
 6333        '''
 6334
 6335        '''
 6336        self.client_key = client_key if client_key is not None else ''
 6337        '''
 6338
 6339        '''
 6340        self.egress_filter = egress_filter if egress_filter is not None else ''
 6341        '''
 6342         A filter applied to the routing logic to pin datasource to nodes.
 6343        '''
 6344        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6345        '''
 6346         The path used to check the health of your connection.  Defaults to `default`.
 6347        '''
 6348        self.healthy = healthy if healthy is not None else False
 6349        '''
 6350         True if the datasource is reachable and the credentials are valid.
 6351        '''
 6352        self.hostname = hostname if hostname is not None else ''
 6353        '''
 6354
 6355        '''
 6356        self.id = id if id is not None else ''
 6357        '''
 6358         Unique identifier of the Resource.
 6359        '''
 6360        self.name = name if name is not None else ''
 6361        '''
 6362         Unique human-readable name of the Resource.
 6363        '''
 6364        self.port = port if port is not None else 0
 6365        '''
 6366
 6367        '''
 6368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6369        '''
 6370         ID of the secret store containing credentials for this resource, if any.
 6371        '''
 6372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6373        '''
 6374         Tags is a map of key, value pairs.
 6375        '''
 6376
 6377    def __repr__(self):
 6378        return '<sdm.KubernetesUserImpersonation ' + \
 6379            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6380            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6381            'client_key: ' + repr(self.client_key) + ' ' +\
 6382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6383            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6384            'healthy: ' + repr(self.healthy) + ' ' +\
 6385            'hostname: ' + repr(self.hostname) + ' ' +\
 6386            'id: ' + repr(self.id) + ' ' +\
 6387            'name: ' + repr(self.name) + ' ' +\
 6388            'port: ' + repr(self.port) + ' ' +\
 6389            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6390            'tags: ' + repr(self.tags) + ' ' +\
 6391            '>'
 6392
 6393    def to_dict(self):
 6394        return {
 6395            'certificate_authority': self.certificate_authority,
 6396            'client_certificate': self.client_certificate,
 6397            'client_key': self.client_key,
 6398            'egress_filter': self.egress_filter,
 6399            'healthcheck_namespace': self.healthcheck_namespace,
 6400            'healthy': self.healthy,
 6401            'hostname': self.hostname,
 6402            'id': self.id,
 6403            'name': self.name,
 6404            'port': self.port,
 6405            'secret_store_id': self.secret_store_id,
 6406            'tags': self.tags,
 6407        }
 6408
 6409    @classmethod
 6410    def from_dict(cls, d):
 6411        return cls(
 6412            certificate_authority=d.get('certificate_authority'),
 6413            client_certificate=d.get('client_certificate'),
 6414            client_key=d.get('client_key'),
 6415            egress_filter=d.get('egress_filter'),
 6416            healthcheck_namespace=d.get('healthcheck_namespace'),
 6417            healthy=d.get('healthy'),
 6418            hostname=d.get('hostname'),
 6419            id=d.get('id'),
 6420            name=d.get('name'),
 6421            port=d.get('port'),
 6422            secret_store_id=d.get('secret_store_id'),
 6423            tags=d.get('tags'),
 6424        )
 6425
 6426
 6427class MTLSMysql:
 6428    '''
 6429
 6430    '''
 6431    __slots__ = [
 6432        'certificate_authority',
 6433        'client_certificate',
 6434        'client_key',
 6435        'database',
 6436        'egress_filter',
 6437        'healthy',
 6438        'hostname',
 6439        'id',
 6440        'name',
 6441        'password',
 6442        'port',
 6443        'port_override',
 6444        'secret_store_id',
 6445        'server_name',
 6446        'tags',
 6447        'username',
 6448    ]
 6449
 6450    def __init__(
 6451        self,
 6452        certificate_authority=None,
 6453        client_certificate=None,
 6454        client_key=None,
 6455        database=None,
 6456        egress_filter=None,
 6457        healthy=None,
 6458        hostname=None,
 6459        id=None,
 6460        name=None,
 6461        password=None,
 6462        port=None,
 6463        port_override=None,
 6464        secret_store_id=None,
 6465        server_name=None,
 6466        tags=None,
 6467        username=None,
 6468    ):
 6469        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6470        '''
 6471
 6472        '''
 6473        self.client_certificate = client_certificate if client_certificate is not None else ''
 6474        '''
 6475
 6476        '''
 6477        self.client_key = client_key if client_key is not None else ''
 6478        '''
 6479
 6480        '''
 6481        self.database = database if database is not None else ''
 6482        '''
 6483
 6484        '''
 6485        self.egress_filter = egress_filter if egress_filter is not None else ''
 6486        '''
 6487         A filter applied to the routing logic to pin datasource to nodes.
 6488        '''
 6489        self.healthy = healthy if healthy is not None else False
 6490        '''
 6491         True if the datasource is reachable and the credentials are valid.
 6492        '''
 6493        self.hostname = hostname if hostname is not None else ''
 6494        '''
 6495
 6496        '''
 6497        self.id = id if id is not None else ''
 6498        '''
 6499         Unique identifier of the Resource.
 6500        '''
 6501        self.name = name if name is not None else ''
 6502        '''
 6503         Unique human-readable name of the Resource.
 6504        '''
 6505        self.password = password if password is not None else ''
 6506        '''
 6507
 6508        '''
 6509        self.port = port if port is not None else 0
 6510        '''
 6511
 6512        '''
 6513        self.port_override = port_override if port_override is not None else 0
 6514        '''
 6515
 6516        '''
 6517        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6518        '''
 6519         ID of the secret store containing credentials for this resource, if any.
 6520        '''
 6521        self.server_name = server_name if server_name is not None else ''
 6522        '''
 6523
 6524        '''
 6525        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6526        '''
 6527         Tags is a map of key, value pairs.
 6528        '''
 6529        self.username = username if username is not None else ''
 6530        '''
 6531
 6532        '''
 6533
 6534    def __repr__(self):
 6535        return '<sdm.MTLSMysql ' + \
 6536            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6537            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6538            'client_key: ' + repr(self.client_key) + ' ' +\
 6539            'database: ' + repr(self.database) + ' ' +\
 6540            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6541            'healthy: ' + repr(self.healthy) + ' ' +\
 6542            'hostname: ' + repr(self.hostname) + ' ' +\
 6543            'id: ' + repr(self.id) + ' ' +\
 6544            'name: ' + repr(self.name) + ' ' +\
 6545            'password: ' + repr(self.password) + ' ' +\
 6546            'port: ' + repr(self.port) + ' ' +\
 6547            'port_override: ' + repr(self.port_override) + ' ' +\
 6548            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6549            'server_name: ' + repr(self.server_name) + ' ' +\
 6550            'tags: ' + repr(self.tags) + ' ' +\
 6551            'username: ' + repr(self.username) + ' ' +\
 6552            '>'
 6553
 6554    def to_dict(self):
 6555        return {
 6556            'certificate_authority': self.certificate_authority,
 6557            'client_certificate': self.client_certificate,
 6558            'client_key': self.client_key,
 6559            'database': self.database,
 6560            'egress_filter': self.egress_filter,
 6561            'healthy': self.healthy,
 6562            'hostname': self.hostname,
 6563            'id': self.id,
 6564            'name': self.name,
 6565            'password': self.password,
 6566            'port': self.port,
 6567            'port_override': self.port_override,
 6568            'secret_store_id': self.secret_store_id,
 6569            'server_name': self.server_name,
 6570            'tags': self.tags,
 6571            'username': self.username,
 6572        }
 6573
 6574    @classmethod
 6575    def from_dict(cls, d):
 6576        return cls(
 6577            certificate_authority=d.get('certificate_authority'),
 6578            client_certificate=d.get('client_certificate'),
 6579            client_key=d.get('client_key'),
 6580            database=d.get('database'),
 6581            egress_filter=d.get('egress_filter'),
 6582            healthy=d.get('healthy'),
 6583            hostname=d.get('hostname'),
 6584            id=d.get('id'),
 6585            name=d.get('name'),
 6586            password=d.get('password'),
 6587            port=d.get('port'),
 6588            port_override=d.get('port_override'),
 6589            secret_store_id=d.get('secret_store_id'),
 6590            server_name=d.get('server_name'),
 6591            tags=d.get('tags'),
 6592            username=d.get('username'),
 6593        )
 6594
 6595
 6596class MTLSPostgres:
 6597    '''
 6598
 6599    '''
 6600    __slots__ = [
 6601        'certificate_authority',
 6602        'client_certificate',
 6603        'client_key',
 6604        'database',
 6605        'egress_filter',
 6606        'healthy',
 6607        'hostname',
 6608        'id',
 6609        'name',
 6610        'override_database',
 6611        'password',
 6612        'port',
 6613        'port_override',
 6614        'secret_store_id',
 6615        'server_name',
 6616        'tags',
 6617        'username',
 6618    ]
 6619
 6620    def __init__(
 6621        self,
 6622        certificate_authority=None,
 6623        client_certificate=None,
 6624        client_key=None,
 6625        database=None,
 6626        egress_filter=None,
 6627        healthy=None,
 6628        hostname=None,
 6629        id=None,
 6630        name=None,
 6631        override_database=None,
 6632        password=None,
 6633        port=None,
 6634        port_override=None,
 6635        secret_store_id=None,
 6636        server_name=None,
 6637        tags=None,
 6638        username=None,
 6639    ):
 6640        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6641        '''
 6642
 6643        '''
 6644        self.client_certificate = client_certificate if client_certificate is not None else ''
 6645        '''
 6646
 6647        '''
 6648        self.client_key = client_key if client_key is not None else ''
 6649        '''
 6650
 6651        '''
 6652        self.database = database if database is not None else ''
 6653        '''
 6654
 6655        '''
 6656        self.egress_filter = egress_filter if egress_filter is not None else ''
 6657        '''
 6658         A filter applied to the routing logic to pin datasource to nodes.
 6659        '''
 6660        self.healthy = healthy if healthy is not None else False
 6661        '''
 6662         True if the datasource is reachable and the credentials are valid.
 6663        '''
 6664        self.hostname = hostname if hostname is not None else ''
 6665        '''
 6666
 6667        '''
 6668        self.id = id if id is not None else ''
 6669        '''
 6670         Unique identifier of the Resource.
 6671        '''
 6672        self.name = name if name is not None else ''
 6673        '''
 6674         Unique human-readable name of the Resource.
 6675        '''
 6676        self.override_database = override_database if override_database is not None else False
 6677        '''
 6678
 6679        '''
 6680        self.password = password if password is not None else ''
 6681        '''
 6682
 6683        '''
 6684        self.port = port if port is not None else 0
 6685        '''
 6686
 6687        '''
 6688        self.port_override = port_override if port_override is not None else 0
 6689        '''
 6690
 6691        '''
 6692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6693        '''
 6694         ID of the secret store containing credentials for this resource, if any.
 6695        '''
 6696        self.server_name = server_name if server_name is not None else ''
 6697        '''
 6698
 6699        '''
 6700        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6701        '''
 6702         Tags is a map of key, value pairs.
 6703        '''
 6704        self.username = username if username is not None else ''
 6705        '''
 6706
 6707        '''
 6708
 6709    def __repr__(self):
 6710        return '<sdm.MTLSPostgres ' + \
 6711            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6712            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6713            'client_key: ' + repr(self.client_key) + ' ' +\
 6714            'database: ' + repr(self.database) + ' ' +\
 6715            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6716            'healthy: ' + repr(self.healthy) + ' ' +\
 6717            'hostname: ' + repr(self.hostname) + ' ' +\
 6718            'id: ' + repr(self.id) + ' ' +\
 6719            'name: ' + repr(self.name) + ' ' +\
 6720            'override_database: ' + repr(self.override_database) + ' ' +\
 6721            'password: ' + repr(self.password) + ' ' +\
 6722            'port: ' + repr(self.port) + ' ' +\
 6723            'port_override: ' + repr(self.port_override) + ' ' +\
 6724            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6725            'server_name: ' + repr(self.server_name) + ' ' +\
 6726            'tags: ' + repr(self.tags) + ' ' +\
 6727            'username: ' + repr(self.username) + ' ' +\
 6728            '>'
 6729
 6730    def to_dict(self):
 6731        return {
 6732            'certificate_authority': self.certificate_authority,
 6733            'client_certificate': self.client_certificate,
 6734            'client_key': self.client_key,
 6735            'database': self.database,
 6736            'egress_filter': self.egress_filter,
 6737            'healthy': self.healthy,
 6738            'hostname': self.hostname,
 6739            'id': self.id,
 6740            'name': self.name,
 6741            'override_database': self.override_database,
 6742            'password': self.password,
 6743            'port': self.port,
 6744            'port_override': self.port_override,
 6745            'secret_store_id': self.secret_store_id,
 6746            'server_name': self.server_name,
 6747            'tags': self.tags,
 6748            'username': self.username,
 6749        }
 6750
 6751    @classmethod
 6752    def from_dict(cls, d):
 6753        return cls(
 6754            certificate_authority=d.get('certificate_authority'),
 6755            client_certificate=d.get('client_certificate'),
 6756            client_key=d.get('client_key'),
 6757            database=d.get('database'),
 6758            egress_filter=d.get('egress_filter'),
 6759            healthy=d.get('healthy'),
 6760            hostname=d.get('hostname'),
 6761            id=d.get('id'),
 6762            name=d.get('name'),
 6763            override_database=d.get('override_database'),
 6764            password=d.get('password'),
 6765            port=d.get('port'),
 6766            port_override=d.get('port_override'),
 6767            secret_store_id=d.get('secret_store_id'),
 6768            server_name=d.get('server_name'),
 6769            tags=d.get('tags'),
 6770            username=d.get('username'),
 6771        )
 6772
 6773
 6774class Maria:
 6775    '''
 6776
 6777    '''
 6778    __slots__ = [
 6779        'database',
 6780        'egress_filter',
 6781        'healthy',
 6782        'hostname',
 6783        'id',
 6784        'name',
 6785        'password',
 6786        'port',
 6787        'port_override',
 6788        'secret_store_id',
 6789        'tags',
 6790        'username',
 6791    ]
 6792
 6793    def __init__(
 6794        self,
 6795        database=None,
 6796        egress_filter=None,
 6797        healthy=None,
 6798        hostname=None,
 6799        id=None,
 6800        name=None,
 6801        password=None,
 6802        port=None,
 6803        port_override=None,
 6804        secret_store_id=None,
 6805        tags=None,
 6806        username=None,
 6807    ):
 6808        self.database = database if database is not None else ''
 6809        '''
 6810
 6811        '''
 6812        self.egress_filter = egress_filter if egress_filter is not None else ''
 6813        '''
 6814         A filter applied to the routing logic to pin datasource to nodes.
 6815        '''
 6816        self.healthy = healthy if healthy is not None else False
 6817        '''
 6818         True if the datasource is reachable and the credentials are valid.
 6819        '''
 6820        self.hostname = hostname if hostname is not None else ''
 6821        '''
 6822
 6823        '''
 6824        self.id = id if id is not None else ''
 6825        '''
 6826         Unique identifier of the Resource.
 6827        '''
 6828        self.name = name if name is not None else ''
 6829        '''
 6830         Unique human-readable name of the Resource.
 6831        '''
 6832        self.password = password if password is not None else ''
 6833        '''
 6834
 6835        '''
 6836        self.port = port if port is not None else 0
 6837        '''
 6838
 6839        '''
 6840        self.port_override = port_override if port_override is not None else 0
 6841        '''
 6842
 6843        '''
 6844        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6845        '''
 6846         ID of the secret store containing credentials for this resource, if any.
 6847        '''
 6848        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6849        '''
 6850         Tags is a map of key, value pairs.
 6851        '''
 6852        self.username = username if username is not None else ''
 6853        '''
 6854
 6855        '''
 6856
 6857    def __repr__(self):
 6858        return '<sdm.Maria ' + \
 6859            'database: ' + repr(self.database) + ' ' +\
 6860            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6861            'healthy: ' + repr(self.healthy) + ' ' +\
 6862            'hostname: ' + repr(self.hostname) + ' ' +\
 6863            'id: ' + repr(self.id) + ' ' +\
 6864            'name: ' + repr(self.name) + ' ' +\
 6865            'password: ' + repr(self.password) + ' ' +\
 6866            'port: ' + repr(self.port) + ' ' +\
 6867            'port_override: ' + repr(self.port_override) + ' ' +\
 6868            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6869            'tags: ' + repr(self.tags) + ' ' +\
 6870            'username: ' + repr(self.username) + ' ' +\
 6871            '>'
 6872
 6873    def to_dict(self):
 6874        return {
 6875            'database': self.database,
 6876            'egress_filter': self.egress_filter,
 6877            'healthy': self.healthy,
 6878            'hostname': self.hostname,
 6879            'id': self.id,
 6880            'name': self.name,
 6881            'password': self.password,
 6882            'port': self.port,
 6883            'port_override': self.port_override,
 6884            'secret_store_id': self.secret_store_id,
 6885            'tags': self.tags,
 6886            'username': self.username,
 6887        }
 6888
 6889    @classmethod
 6890    def from_dict(cls, d):
 6891        return cls(
 6892            database=d.get('database'),
 6893            egress_filter=d.get('egress_filter'),
 6894            healthy=d.get('healthy'),
 6895            hostname=d.get('hostname'),
 6896            id=d.get('id'),
 6897            name=d.get('name'),
 6898            password=d.get('password'),
 6899            port=d.get('port'),
 6900            port_override=d.get('port_override'),
 6901            secret_store_id=d.get('secret_store_id'),
 6902            tags=d.get('tags'),
 6903            username=d.get('username'),
 6904        )
 6905
 6906
 6907class Memcached:
 6908    '''
 6909
 6910    '''
 6911    __slots__ = [
 6912        'egress_filter',
 6913        'healthy',
 6914        'hostname',
 6915        'id',
 6916        'name',
 6917        'port',
 6918        'port_override',
 6919        'secret_store_id',
 6920        'tags',
 6921    ]
 6922
 6923    def __init__(
 6924        self,
 6925        egress_filter=None,
 6926        healthy=None,
 6927        hostname=None,
 6928        id=None,
 6929        name=None,
 6930        port=None,
 6931        port_override=None,
 6932        secret_store_id=None,
 6933        tags=None,
 6934    ):
 6935        self.egress_filter = egress_filter if egress_filter is not None else ''
 6936        '''
 6937         A filter applied to the routing logic to pin datasource to nodes.
 6938        '''
 6939        self.healthy = healthy if healthy is not None else False
 6940        '''
 6941         True if the datasource is reachable and the credentials are valid.
 6942        '''
 6943        self.hostname = hostname if hostname is not None else ''
 6944        '''
 6945
 6946        '''
 6947        self.id = id if id is not None else ''
 6948        '''
 6949         Unique identifier of the Resource.
 6950        '''
 6951        self.name = name if name is not None else ''
 6952        '''
 6953         Unique human-readable name of the Resource.
 6954        '''
 6955        self.port = port if port is not None else 0
 6956        '''
 6957
 6958        '''
 6959        self.port_override = port_override if port_override is not None else 0
 6960        '''
 6961
 6962        '''
 6963        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6964        '''
 6965         ID of the secret store containing credentials for this resource, if any.
 6966        '''
 6967        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6968        '''
 6969         Tags is a map of key, value pairs.
 6970        '''
 6971
 6972    def __repr__(self):
 6973        return '<sdm.Memcached ' + \
 6974            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6975            'healthy: ' + repr(self.healthy) + ' ' +\
 6976            'hostname: ' + repr(self.hostname) + ' ' +\
 6977            'id: ' + repr(self.id) + ' ' +\
 6978            'name: ' + repr(self.name) + ' ' +\
 6979            'port: ' + repr(self.port) + ' ' +\
 6980            'port_override: ' + repr(self.port_override) + ' ' +\
 6981            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6982            'tags: ' + repr(self.tags) + ' ' +\
 6983            '>'
 6984
 6985    def to_dict(self):
 6986        return {
 6987            'egress_filter': self.egress_filter,
 6988            'healthy': self.healthy,
 6989            'hostname': self.hostname,
 6990            'id': self.id,
 6991            'name': self.name,
 6992            'port': self.port,
 6993            'port_override': self.port_override,
 6994            'secret_store_id': self.secret_store_id,
 6995            'tags': self.tags,
 6996        }
 6997
 6998    @classmethod
 6999    def from_dict(cls, d):
 7000        return cls(
 7001            egress_filter=d.get('egress_filter'),
 7002            healthy=d.get('healthy'),
 7003            hostname=d.get('hostname'),
 7004            id=d.get('id'),
 7005            name=d.get('name'),
 7006            port=d.get('port'),
 7007            port_override=d.get('port_override'),
 7008            secret_store_id=d.get('secret_store_id'),
 7009            tags=d.get('tags'),
 7010        )
 7011
 7012
 7013class Memsql:
 7014    '''
 7015
 7016    '''
 7017    __slots__ = [
 7018        'database',
 7019        'egress_filter',
 7020        'healthy',
 7021        'hostname',
 7022        'id',
 7023        'name',
 7024        'password',
 7025        'port',
 7026        'port_override',
 7027        'secret_store_id',
 7028        'tags',
 7029        'username',
 7030    ]
 7031
 7032    def __init__(
 7033        self,
 7034        database=None,
 7035        egress_filter=None,
 7036        healthy=None,
 7037        hostname=None,
 7038        id=None,
 7039        name=None,
 7040        password=None,
 7041        port=None,
 7042        port_override=None,
 7043        secret_store_id=None,
 7044        tags=None,
 7045        username=None,
 7046    ):
 7047        self.database = database if database is not None else ''
 7048        '''
 7049
 7050        '''
 7051        self.egress_filter = egress_filter if egress_filter is not None else ''
 7052        '''
 7053         A filter applied to the routing logic to pin datasource to nodes.
 7054        '''
 7055        self.healthy = healthy if healthy is not None else False
 7056        '''
 7057         True if the datasource is reachable and the credentials are valid.
 7058        '''
 7059        self.hostname = hostname if hostname is not None else ''
 7060        '''
 7061
 7062        '''
 7063        self.id = id if id is not None else ''
 7064        '''
 7065         Unique identifier of the Resource.
 7066        '''
 7067        self.name = name if name is not None else ''
 7068        '''
 7069         Unique human-readable name of the Resource.
 7070        '''
 7071        self.password = password if password is not None else ''
 7072        '''
 7073
 7074        '''
 7075        self.port = port if port is not None else 0
 7076        '''
 7077
 7078        '''
 7079        self.port_override = port_override if port_override is not None else 0
 7080        '''
 7081
 7082        '''
 7083        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7084        '''
 7085         ID of the secret store containing credentials for this resource, if any.
 7086        '''
 7087        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7088        '''
 7089         Tags is a map of key, value pairs.
 7090        '''
 7091        self.username = username if username is not None else ''
 7092        '''
 7093
 7094        '''
 7095
 7096    def __repr__(self):
 7097        return '<sdm.Memsql ' + \
 7098            'database: ' + repr(self.database) + ' ' +\
 7099            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7100            'healthy: ' + repr(self.healthy) + ' ' +\
 7101            'hostname: ' + repr(self.hostname) + ' ' +\
 7102            'id: ' + repr(self.id) + ' ' +\
 7103            'name: ' + repr(self.name) + ' ' +\
 7104            'password: ' + repr(self.password) + ' ' +\
 7105            'port: ' + repr(self.port) + ' ' +\
 7106            'port_override: ' + repr(self.port_override) + ' ' +\
 7107            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7108            'tags: ' + repr(self.tags) + ' ' +\
 7109            'username: ' + repr(self.username) + ' ' +\
 7110            '>'
 7111
 7112    def to_dict(self):
 7113        return {
 7114            'database': self.database,
 7115            'egress_filter': self.egress_filter,
 7116            'healthy': self.healthy,
 7117            'hostname': self.hostname,
 7118            'id': self.id,
 7119            'name': self.name,
 7120            'password': self.password,
 7121            'port': self.port,
 7122            'port_override': self.port_override,
 7123            'secret_store_id': self.secret_store_id,
 7124            'tags': self.tags,
 7125            'username': self.username,
 7126        }
 7127
 7128    @classmethod
 7129    def from_dict(cls, d):
 7130        return cls(
 7131            database=d.get('database'),
 7132            egress_filter=d.get('egress_filter'),
 7133            healthy=d.get('healthy'),
 7134            hostname=d.get('hostname'),
 7135            id=d.get('id'),
 7136            name=d.get('name'),
 7137            password=d.get('password'),
 7138            port=d.get('port'),
 7139            port_override=d.get('port_override'),
 7140            secret_store_id=d.get('secret_store_id'),
 7141            tags=d.get('tags'),
 7142            username=d.get('username'),
 7143        )
 7144
 7145
 7146class MongoHost:
 7147    '''
 7148
 7149    '''
 7150    __slots__ = [
 7151        'auth_database',
 7152        'egress_filter',
 7153        'healthy',
 7154        'hostname',
 7155        'id',
 7156        'name',
 7157        'password',
 7158        'port',
 7159        'port_override',
 7160        'secret_store_id',
 7161        'tags',
 7162        'tls_required',
 7163        'username',
 7164    ]
 7165
 7166    def __init__(
 7167        self,
 7168        auth_database=None,
 7169        egress_filter=None,
 7170        healthy=None,
 7171        hostname=None,
 7172        id=None,
 7173        name=None,
 7174        password=None,
 7175        port=None,
 7176        port_override=None,
 7177        secret_store_id=None,
 7178        tags=None,
 7179        tls_required=None,
 7180        username=None,
 7181    ):
 7182        self.auth_database = auth_database if auth_database is not None else ''
 7183        '''
 7184
 7185        '''
 7186        self.egress_filter = egress_filter if egress_filter is not None else ''
 7187        '''
 7188         A filter applied to the routing logic to pin datasource to nodes.
 7189        '''
 7190        self.healthy = healthy if healthy is not None else False
 7191        '''
 7192         True if the datasource is reachable and the credentials are valid.
 7193        '''
 7194        self.hostname = hostname if hostname is not None else ''
 7195        '''
 7196
 7197        '''
 7198        self.id = id if id is not None else ''
 7199        '''
 7200         Unique identifier of the Resource.
 7201        '''
 7202        self.name = name if name is not None else ''
 7203        '''
 7204         Unique human-readable name of the Resource.
 7205        '''
 7206        self.password = password if password is not None else ''
 7207        '''
 7208
 7209        '''
 7210        self.port = port if port is not None else 0
 7211        '''
 7212
 7213        '''
 7214        self.port_override = port_override if port_override is not None else 0
 7215        '''
 7216
 7217        '''
 7218        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7219        '''
 7220         ID of the secret store containing credentials for this resource, if any.
 7221        '''
 7222        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7223        '''
 7224         Tags is a map of key, value pairs.
 7225        '''
 7226        self.tls_required = tls_required if tls_required is not None else False
 7227        '''
 7228
 7229        '''
 7230        self.username = username if username is not None else ''
 7231        '''
 7232
 7233        '''
 7234
 7235    def __repr__(self):
 7236        return '<sdm.MongoHost ' + \
 7237            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7238            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7239            'healthy: ' + repr(self.healthy) + ' ' +\
 7240            'hostname: ' + repr(self.hostname) + ' ' +\
 7241            'id: ' + repr(self.id) + ' ' +\
 7242            'name: ' + repr(self.name) + ' ' +\
 7243            'password: ' + repr(self.password) + ' ' +\
 7244            'port: ' + repr(self.port) + ' ' +\
 7245            'port_override: ' + repr(self.port_override) + ' ' +\
 7246            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7247            'tags: ' + repr(self.tags) + ' ' +\
 7248            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7249            'username: ' + repr(self.username) + ' ' +\
 7250            '>'
 7251
 7252    def to_dict(self):
 7253        return {
 7254            'auth_database': self.auth_database,
 7255            'egress_filter': self.egress_filter,
 7256            'healthy': self.healthy,
 7257            'hostname': self.hostname,
 7258            'id': self.id,
 7259            'name': self.name,
 7260            'password': self.password,
 7261            'port': self.port,
 7262            'port_override': self.port_override,
 7263            'secret_store_id': self.secret_store_id,
 7264            'tags': self.tags,
 7265            'tls_required': self.tls_required,
 7266            'username': self.username,
 7267        }
 7268
 7269    @classmethod
 7270    def from_dict(cls, d):
 7271        return cls(
 7272            auth_database=d.get('auth_database'),
 7273            egress_filter=d.get('egress_filter'),
 7274            healthy=d.get('healthy'),
 7275            hostname=d.get('hostname'),
 7276            id=d.get('id'),
 7277            name=d.get('name'),
 7278            password=d.get('password'),
 7279            port=d.get('port'),
 7280            port_override=d.get('port_override'),
 7281            secret_store_id=d.get('secret_store_id'),
 7282            tags=d.get('tags'),
 7283            tls_required=d.get('tls_required'),
 7284            username=d.get('username'),
 7285        )
 7286
 7287
 7288class MongoLegacyHost:
 7289    '''
 7290
 7291    '''
 7292    __slots__ = [
 7293        'auth_database',
 7294        'egress_filter',
 7295        'healthy',
 7296        'hostname',
 7297        'id',
 7298        'name',
 7299        'password',
 7300        'port',
 7301        'port_override',
 7302        'replica_set',
 7303        'secret_store_id',
 7304        'tags',
 7305        'tls_required',
 7306        'username',
 7307    ]
 7308
 7309    def __init__(
 7310        self,
 7311        auth_database=None,
 7312        egress_filter=None,
 7313        healthy=None,
 7314        hostname=None,
 7315        id=None,
 7316        name=None,
 7317        password=None,
 7318        port=None,
 7319        port_override=None,
 7320        replica_set=None,
 7321        secret_store_id=None,
 7322        tags=None,
 7323        tls_required=None,
 7324        username=None,
 7325    ):
 7326        self.auth_database = auth_database if auth_database is not None else ''
 7327        '''
 7328
 7329        '''
 7330        self.egress_filter = egress_filter if egress_filter is not None else ''
 7331        '''
 7332         A filter applied to the routing logic to pin datasource to nodes.
 7333        '''
 7334        self.healthy = healthy if healthy is not None else False
 7335        '''
 7336         True if the datasource is reachable and the credentials are valid.
 7337        '''
 7338        self.hostname = hostname if hostname is not None else ''
 7339        '''
 7340
 7341        '''
 7342        self.id = id if id is not None else ''
 7343        '''
 7344         Unique identifier of the Resource.
 7345        '''
 7346        self.name = name if name is not None else ''
 7347        '''
 7348         Unique human-readable name of the Resource.
 7349        '''
 7350        self.password = password if password is not None else ''
 7351        '''
 7352
 7353        '''
 7354        self.port = port if port is not None else 0
 7355        '''
 7356
 7357        '''
 7358        self.port_override = port_override if port_override is not None else 0
 7359        '''
 7360
 7361        '''
 7362        self.replica_set = replica_set if replica_set is not None else ''
 7363        '''
 7364
 7365        '''
 7366        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7367        '''
 7368         ID of the secret store containing credentials for this resource, if any.
 7369        '''
 7370        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7371        '''
 7372         Tags is a map of key, value pairs.
 7373        '''
 7374        self.tls_required = tls_required if tls_required is not None else False
 7375        '''
 7376
 7377        '''
 7378        self.username = username if username is not None else ''
 7379        '''
 7380
 7381        '''
 7382
 7383    def __repr__(self):
 7384        return '<sdm.MongoLegacyHost ' + \
 7385            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7386            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7387            'healthy: ' + repr(self.healthy) + ' ' +\
 7388            'hostname: ' + repr(self.hostname) + ' ' +\
 7389            'id: ' + repr(self.id) + ' ' +\
 7390            'name: ' + repr(self.name) + ' ' +\
 7391            'password: ' + repr(self.password) + ' ' +\
 7392            'port: ' + repr(self.port) + ' ' +\
 7393            'port_override: ' + repr(self.port_override) + ' ' +\
 7394            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7395            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7396            'tags: ' + repr(self.tags) + ' ' +\
 7397            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7398            'username: ' + repr(self.username) + ' ' +\
 7399            '>'
 7400
 7401    def to_dict(self):
 7402        return {
 7403            'auth_database': self.auth_database,
 7404            'egress_filter': self.egress_filter,
 7405            'healthy': self.healthy,
 7406            'hostname': self.hostname,
 7407            'id': self.id,
 7408            'name': self.name,
 7409            'password': self.password,
 7410            'port': self.port,
 7411            'port_override': self.port_override,
 7412            'replica_set': self.replica_set,
 7413            'secret_store_id': self.secret_store_id,
 7414            'tags': self.tags,
 7415            'tls_required': self.tls_required,
 7416            'username': self.username,
 7417        }
 7418
 7419    @classmethod
 7420    def from_dict(cls, d):
 7421        return cls(
 7422            auth_database=d.get('auth_database'),
 7423            egress_filter=d.get('egress_filter'),
 7424            healthy=d.get('healthy'),
 7425            hostname=d.get('hostname'),
 7426            id=d.get('id'),
 7427            name=d.get('name'),
 7428            password=d.get('password'),
 7429            port=d.get('port'),
 7430            port_override=d.get('port_override'),
 7431            replica_set=d.get('replica_set'),
 7432            secret_store_id=d.get('secret_store_id'),
 7433            tags=d.get('tags'),
 7434            tls_required=d.get('tls_required'),
 7435            username=d.get('username'),
 7436        )
 7437
 7438
 7439class MongoLegacyReplicaset:
 7440    '''
 7441
 7442    '''
 7443    __slots__ = [
 7444        'auth_database',
 7445        'connect_to_replica',
 7446        'egress_filter',
 7447        'healthy',
 7448        'hostname',
 7449        'id',
 7450        'name',
 7451        'password',
 7452        'port',
 7453        'port_override',
 7454        'replica_set',
 7455        'secret_store_id',
 7456        'tags',
 7457        'tls_required',
 7458        'username',
 7459    ]
 7460
 7461    def __init__(
 7462        self,
 7463        auth_database=None,
 7464        connect_to_replica=None,
 7465        egress_filter=None,
 7466        healthy=None,
 7467        hostname=None,
 7468        id=None,
 7469        name=None,
 7470        password=None,
 7471        port=None,
 7472        port_override=None,
 7473        replica_set=None,
 7474        secret_store_id=None,
 7475        tags=None,
 7476        tls_required=None,
 7477        username=None,
 7478    ):
 7479        self.auth_database = auth_database if auth_database is not None else ''
 7480        '''
 7481
 7482        '''
 7483        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7484        '''
 7485
 7486        '''
 7487        self.egress_filter = egress_filter if egress_filter is not None else ''
 7488        '''
 7489         A filter applied to the routing logic to pin datasource to nodes.
 7490        '''
 7491        self.healthy = healthy if healthy is not None else False
 7492        '''
 7493         True if the datasource is reachable and the credentials are valid.
 7494        '''
 7495        self.hostname = hostname if hostname is not None else ''
 7496        '''
 7497
 7498        '''
 7499        self.id = id if id is not None else ''
 7500        '''
 7501         Unique identifier of the Resource.
 7502        '''
 7503        self.name = name if name is not None else ''
 7504        '''
 7505         Unique human-readable name of the Resource.
 7506        '''
 7507        self.password = password if password is not None else ''
 7508        '''
 7509
 7510        '''
 7511        self.port = port if port is not None else 0
 7512        '''
 7513
 7514        '''
 7515        self.port_override = port_override if port_override is not None else 0
 7516        '''
 7517
 7518        '''
 7519        self.replica_set = replica_set if replica_set is not None else ''
 7520        '''
 7521
 7522        '''
 7523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7524        '''
 7525         ID of the secret store containing credentials for this resource, if any.
 7526        '''
 7527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7528        '''
 7529         Tags is a map of key, value pairs.
 7530        '''
 7531        self.tls_required = tls_required if tls_required is not None else False
 7532        '''
 7533
 7534        '''
 7535        self.username = username if username is not None else ''
 7536        '''
 7537
 7538        '''
 7539
 7540    def __repr__(self):
 7541        return '<sdm.MongoLegacyReplicaset ' + \
 7542            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7543            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7544            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7545            'healthy: ' + repr(self.healthy) + ' ' +\
 7546            'hostname: ' + repr(self.hostname) + ' ' +\
 7547            'id: ' + repr(self.id) + ' ' +\
 7548            'name: ' + repr(self.name) + ' ' +\
 7549            'password: ' + repr(self.password) + ' ' +\
 7550            'port: ' + repr(self.port) + ' ' +\
 7551            'port_override: ' + repr(self.port_override) + ' ' +\
 7552            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7553            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7554            'tags: ' + repr(self.tags) + ' ' +\
 7555            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7556            'username: ' + repr(self.username) + ' ' +\
 7557            '>'
 7558
 7559    def to_dict(self):
 7560        return {
 7561            'auth_database': self.auth_database,
 7562            'connect_to_replica': self.connect_to_replica,
 7563            'egress_filter': self.egress_filter,
 7564            'healthy': self.healthy,
 7565            'hostname': self.hostname,
 7566            'id': self.id,
 7567            'name': self.name,
 7568            'password': self.password,
 7569            'port': self.port,
 7570            'port_override': self.port_override,
 7571            'replica_set': self.replica_set,
 7572            'secret_store_id': self.secret_store_id,
 7573            'tags': self.tags,
 7574            'tls_required': self.tls_required,
 7575            'username': self.username,
 7576        }
 7577
 7578    @classmethod
 7579    def from_dict(cls, d):
 7580        return cls(
 7581            auth_database=d.get('auth_database'),
 7582            connect_to_replica=d.get('connect_to_replica'),
 7583            egress_filter=d.get('egress_filter'),
 7584            healthy=d.get('healthy'),
 7585            hostname=d.get('hostname'),
 7586            id=d.get('id'),
 7587            name=d.get('name'),
 7588            password=d.get('password'),
 7589            port=d.get('port'),
 7590            port_override=d.get('port_override'),
 7591            replica_set=d.get('replica_set'),
 7592            secret_store_id=d.get('secret_store_id'),
 7593            tags=d.get('tags'),
 7594            tls_required=d.get('tls_required'),
 7595            username=d.get('username'),
 7596        )
 7597
 7598
 7599class MongoReplicaSet:
 7600    '''
 7601
 7602    '''
 7603    __slots__ = [
 7604        'auth_database',
 7605        'connect_to_replica',
 7606        'egress_filter',
 7607        'healthy',
 7608        'hostname',
 7609        'id',
 7610        'name',
 7611        'password',
 7612        'port',
 7613        'port_override',
 7614        'replica_set',
 7615        'secret_store_id',
 7616        'tags',
 7617        'tls_required',
 7618        'username',
 7619    ]
 7620
 7621    def __init__(
 7622        self,
 7623        auth_database=None,
 7624        connect_to_replica=None,
 7625        egress_filter=None,
 7626        healthy=None,
 7627        hostname=None,
 7628        id=None,
 7629        name=None,
 7630        password=None,
 7631        port=None,
 7632        port_override=None,
 7633        replica_set=None,
 7634        secret_store_id=None,
 7635        tags=None,
 7636        tls_required=None,
 7637        username=None,
 7638    ):
 7639        self.auth_database = auth_database if auth_database is not None else ''
 7640        '''
 7641
 7642        '''
 7643        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7644        '''
 7645
 7646        '''
 7647        self.egress_filter = egress_filter if egress_filter is not None else ''
 7648        '''
 7649         A filter applied to the routing logic to pin datasource to nodes.
 7650        '''
 7651        self.healthy = healthy if healthy is not None else False
 7652        '''
 7653         True if the datasource is reachable and the credentials are valid.
 7654        '''
 7655        self.hostname = hostname if hostname is not None else ''
 7656        '''
 7657
 7658        '''
 7659        self.id = id if id is not None else ''
 7660        '''
 7661         Unique identifier of the Resource.
 7662        '''
 7663        self.name = name if name is not None else ''
 7664        '''
 7665         Unique human-readable name of the Resource.
 7666        '''
 7667        self.password = password if password is not None else ''
 7668        '''
 7669
 7670        '''
 7671        self.port = port if port is not None else 0
 7672        '''
 7673
 7674        '''
 7675        self.port_override = port_override if port_override is not None else 0
 7676        '''
 7677
 7678        '''
 7679        self.replica_set = replica_set if replica_set is not None else ''
 7680        '''
 7681
 7682        '''
 7683        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7684        '''
 7685         ID of the secret store containing credentials for this resource, if any.
 7686        '''
 7687        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7688        '''
 7689         Tags is a map of key, value pairs.
 7690        '''
 7691        self.tls_required = tls_required if tls_required is not None else False
 7692        '''
 7693
 7694        '''
 7695        self.username = username if username is not None else ''
 7696        '''
 7697
 7698        '''
 7699
 7700    def __repr__(self):
 7701        return '<sdm.MongoReplicaSet ' + \
 7702            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7703            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7704            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7705            'healthy: ' + repr(self.healthy) + ' ' +\
 7706            'hostname: ' + repr(self.hostname) + ' ' +\
 7707            'id: ' + repr(self.id) + ' ' +\
 7708            'name: ' + repr(self.name) + ' ' +\
 7709            'password: ' + repr(self.password) + ' ' +\
 7710            'port: ' + repr(self.port) + ' ' +\
 7711            'port_override: ' + repr(self.port_override) + ' ' +\
 7712            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7713            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7714            'tags: ' + repr(self.tags) + ' ' +\
 7715            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7716            'username: ' + repr(self.username) + ' ' +\
 7717            '>'
 7718
 7719    def to_dict(self):
 7720        return {
 7721            'auth_database': self.auth_database,
 7722            'connect_to_replica': self.connect_to_replica,
 7723            'egress_filter': self.egress_filter,
 7724            'healthy': self.healthy,
 7725            'hostname': self.hostname,
 7726            'id': self.id,
 7727            'name': self.name,
 7728            'password': self.password,
 7729            'port': self.port,
 7730            'port_override': self.port_override,
 7731            'replica_set': self.replica_set,
 7732            'secret_store_id': self.secret_store_id,
 7733            'tags': self.tags,
 7734            'tls_required': self.tls_required,
 7735            'username': self.username,
 7736        }
 7737
 7738    @classmethod
 7739    def from_dict(cls, d):
 7740        return cls(
 7741            auth_database=d.get('auth_database'),
 7742            connect_to_replica=d.get('connect_to_replica'),
 7743            egress_filter=d.get('egress_filter'),
 7744            healthy=d.get('healthy'),
 7745            hostname=d.get('hostname'),
 7746            id=d.get('id'),
 7747            name=d.get('name'),
 7748            password=d.get('password'),
 7749            port=d.get('port'),
 7750            port_override=d.get('port_override'),
 7751            replica_set=d.get('replica_set'),
 7752            secret_store_id=d.get('secret_store_id'),
 7753            tags=d.get('tags'),
 7754            tls_required=d.get('tls_required'),
 7755            username=d.get('username'),
 7756        )
 7757
 7758
 7759class MongoShardedCluster:
 7760    '''
 7761
 7762    '''
 7763    __slots__ = [
 7764        'auth_database',
 7765        'egress_filter',
 7766        'healthy',
 7767        'hostname',
 7768        'id',
 7769        'name',
 7770        'password',
 7771        'port_override',
 7772        'secret_store_id',
 7773        'tags',
 7774        'tls_required',
 7775        'username',
 7776    ]
 7777
 7778    def __init__(
 7779        self,
 7780        auth_database=None,
 7781        egress_filter=None,
 7782        healthy=None,
 7783        hostname=None,
 7784        id=None,
 7785        name=None,
 7786        password=None,
 7787        port_override=None,
 7788        secret_store_id=None,
 7789        tags=None,
 7790        tls_required=None,
 7791        username=None,
 7792    ):
 7793        self.auth_database = auth_database if auth_database is not None else ''
 7794        '''
 7795
 7796        '''
 7797        self.egress_filter = egress_filter if egress_filter is not None else ''
 7798        '''
 7799         A filter applied to the routing logic to pin datasource to nodes.
 7800        '''
 7801        self.healthy = healthy if healthy is not None else False
 7802        '''
 7803         True if the datasource is reachable and the credentials are valid.
 7804        '''
 7805        self.hostname = hostname if hostname is not None else ''
 7806        '''
 7807
 7808        '''
 7809        self.id = id if id is not None else ''
 7810        '''
 7811         Unique identifier of the Resource.
 7812        '''
 7813        self.name = name if name is not None else ''
 7814        '''
 7815         Unique human-readable name of the Resource.
 7816        '''
 7817        self.password = password if password is not None else ''
 7818        '''
 7819
 7820        '''
 7821        self.port_override = port_override if port_override is not None else 0
 7822        '''
 7823
 7824        '''
 7825        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7826        '''
 7827         ID of the secret store containing credentials for this resource, if any.
 7828        '''
 7829        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7830        '''
 7831         Tags is a map of key, value pairs.
 7832        '''
 7833        self.tls_required = tls_required if tls_required is not None else False
 7834        '''
 7835
 7836        '''
 7837        self.username = username if username is not None else ''
 7838        '''
 7839
 7840        '''
 7841
 7842    def __repr__(self):
 7843        return '<sdm.MongoShardedCluster ' + \
 7844            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7845            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7846            'healthy: ' + repr(self.healthy) + ' ' +\
 7847            'hostname: ' + repr(self.hostname) + ' ' +\
 7848            'id: ' + repr(self.id) + ' ' +\
 7849            'name: ' + repr(self.name) + ' ' +\
 7850            'password: ' + repr(self.password) + ' ' +\
 7851            'port_override: ' + repr(self.port_override) + ' ' +\
 7852            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7853            'tags: ' + repr(self.tags) + ' ' +\
 7854            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7855            'username: ' + repr(self.username) + ' ' +\
 7856            '>'
 7857
 7858    def to_dict(self):
 7859        return {
 7860            'auth_database': self.auth_database,
 7861            'egress_filter': self.egress_filter,
 7862            'healthy': self.healthy,
 7863            'hostname': self.hostname,
 7864            'id': self.id,
 7865            'name': self.name,
 7866            'password': self.password,
 7867            'port_override': self.port_override,
 7868            'secret_store_id': self.secret_store_id,
 7869            'tags': self.tags,
 7870            'tls_required': self.tls_required,
 7871            'username': self.username,
 7872        }
 7873
 7874    @classmethod
 7875    def from_dict(cls, d):
 7876        return cls(
 7877            auth_database=d.get('auth_database'),
 7878            egress_filter=d.get('egress_filter'),
 7879            healthy=d.get('healthy'),
 7880            hostname=d.get('hostname'),
 7881            id=d.get('id'),
 7882            name=d.get('name'),
 7883            password=d.get('password'),
 7884            port_override=d.get('port_override'),
 7885            secret_store_id=d.get('secret_store_id'),
 7886            tags=d.get('tags'),
 7887            tls_required=d.get('tls_required'),
 7888            username=d.get('username'),
 7889        )
 7890
 7891
 7892class Mysql:
 7893    '''
 7894
 7895    '''
 7896    __slots__ = [
 7897        'database',
 7898        'egress_filter',
 7899        'healthy',
 7900        'hostname',
 7901        'id',
 7902        'name',
 7903        'password',
 7904        'port',
 7905        'port_override',
 7906        'secret_store_id',
 7907        'tags',
 7908        'username',
 7909    ]
 7910
 7911    def __init__(
 7912        self,
 7913        database=None,
 7914        egress_filter=None,
 7915        healthy=None,
 7916        hostname=None,
 7917        id=None,
 7918        name=None,
 7919        password=None,
 7920        port=None,
 7921        port_override=None,
 7922        secret_store_id=None,
 7923        tags=None,
 7924        username=None,
 7925    ):
 7926        self.database = database if database is not None else ''
 7927        '''
 7928
 7929        '''
 7930        self.egress_filter = egress_filter if egress_filter is not None else ''
 7931        '''
 7932         A filter applied to the routing logic to pin datasource to nodes.
 7933        '''
 7934        self.healthy = healthy if healthy is not None else False
 7935        '''
 7936         True if the datasource is reachable and the credentials are valid.
 7937        '''
 7938        self.hostname = hostname if hostname is not None else ''
 7939        '''
 7940
 7941        '''
 7942        self.id = id if id is not None else ''
 7943        '''
 7944         Unique identifier of the Resource.
 7945        '''
 7946        self.name = name if name is not None else ''
 7947        '''
 7948         Unique human-readable name of the Resource.
 7949        '''
 7950        self.password = password if password is not None else ''
 7951        '''
 7952
 7953        '''
 7954        self.port = port if port is not None else 0
 7955        '''
 7956
 7957        '''
 7958        self.port_override = port_override if port_override is not None else 0
 7959        '''
 7960
 7961        '''
 7962        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7963        '''
 7964         ID of the secret store containing credentials for this resource, if any.
 7965        '''
 7966        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7967        '''
 7968         Tags is a map of key, value pairs.
 7969        '''
 7970        self.username = username if username is not None else ''
 7971        '''
 7972
 7973        '''
 7974
 7975    def __repr__(self):
 7976        return '<sdm.Mysql ' + \
 7977            'database: ' + repr(self.database) + ' ' +\
 7978            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7979            'healthy: ' + repr(self.healthy) + ' ' +\
 7980            'hostname: ' + repr(self.hostname) + ' ' +\
 7981            'id: ' + repr(self.id) + ' ' +\
 7982            'name: ' + repr(self.name) + ' ' +\
 7983            'password: ' + repr(self.password) + ' ' +\
 7984            'port: ' + repr(self.port) + ' ' +\
 7985            'port_override: ' + repr(self.port_override) + ' ' +\
 7986            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7987            'tags: ' + repr(self.tags) + ' ' +\
 7988            'username: ' + repr(self.username) + ' ' +\
 7989            '>'
 7990
 7991    def to_dict(self):
 7992        return {
 7993            'database': self.database,
 7994            'egress_filter': self.egress_filter,
 7995            'healthy': self.healthy,
 7996            'hostname': self.hostname,
 7997            'id': self.id,
 7998            'name': self.name,
 7999            'password': self.password,
 8000            'port': self.port,
 8001            'port_override': self.port_override,
 8002            'secret_store_id': self.secret_store_id,
 8003            'tags': self.tags,
 8004            'username': self.username,
 8005        }
 8006
 8007    @classmethod
 8008    def from_dict(cls, d):
 8009        return cls(
 8010            database=d.get('database'),
 8011            egress_filter=d.get('egress_filter'),
 8012            healthy=d.get('healthy'),
 8013            hostname=d.get('hostname'),
 8014            id=d.get('id'),
 8015            name=d.get('name'),
 8016            password=d.get('password'),
 8017            port=d.get('port'),
 8018            port_override=d.get('port_override'),
 8019            secret_store_id=d.get('secret_store_id'),
 8020            tags=d.get('tags'),
 8021            username=d.get('username'),
 8022        )
 8023
 8024
 8025class Neptune:
 8026    '''
 8027
 8028    '''
 8029    __slots__ = [
 8030        'egress_filter',
 8031        'endpoint',
 8032        'healthy',
 8033        'id',
 8034        'name',
 8035        'port',
 8036        'port_override',
 8037        'secret_store_id',
 8038        'tags',
 8039    ]
 8040
 8041    def __init__(
 8042        self,
 8043        egress_filter=None,
 8044        endpoint=None,
 8045        healthy=None,
 8046        id=None,
 8047        name=None,
 8048        port=None,
 8049        port_override=None,
 8050        secret_store_id=None,
 8051        tags=None,
 8052    ):
 8053        self.egress_filter = egress_filter if egress_filter is not None else ''
 8054        '''
 8055         A filter applied to the routing logic to pin datasource to nodes.
 8056        '''
 8057        self.endpoint = endpoint if endpoint is not None else ''
 8058        '''
 8059
 8060        '''
 8061        self.healthy = healthy if healthy is not None else False
 8062        '''
 8063         True if the datasource is reachable and the credentials are valid.
 8064        '''
 8065        self.id = id if id is not None else ''
 8066        '''
 8067         Unique identifier of the Resource.
 8068        '''
 8069        self.name = name if name is not None else ''
 8070        '''
 8071         Unique human-readable name of the Resource.
 8072        '''
 8073        self.port = port if port is not None else 0
 8074        '''
 8075
 8076        '''
 8077        self.port_override = port_override if port_override is not None else 0
 8078        '''
 8079
 8080        '''
 8081        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8082        '''
 8083         ID of the secret store containing credentials for this resource, if any.
 8084        '''
 8085        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8086        '''
 8087         Tags is a map of key, value pairs.
 8088        '''
 8089
 8090    def __repr__(self):
 8091        return '<sdm.Neptune ' + \
 8092            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8093            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8094            'healthy: ' + repr(self.healthy) + ' ' +\
 8095            'id: ' + repr(self.id) + ' ' +\
 8096            'name: ' + repr(self.name) + ' ' +\
 8097            'port: ' + repr(self.port) + ' ' +\
 8098            'port_override: ' + repr(self.port_override) + ' ' +\
 8099            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8100            'tags: ' + repr(self.tags) + ' ' +\
 8101            '>'
 8102
 8103    def to_dict(self):
 8104        return {
 8105            'egress_filter': self.egress_filter,
 8106            'endpoint': self.endpoint,
 8107            'healthy': self.healthy,
 8108            'id': self.id,
 8109            'name': self.name,
 8110            'port': self.port,
 8111            'port_override': self.port_override,
 8112            'secret_store_id': self.secret_store_id,
 8113            'tags': self.tags,
 8114        }
 8115
 8116    @classmethod
 8117    def from_dict(cls, d):
 8118        return cls(
 8119            egress_filter=d.get('egress_filter'),
 8120            endpoint=d.get('endpoint'),
 8121            healthy=d.get('healthy'),
 8122            id=d.get('id'),
 8123            name=d.get('name'),
 8124            port=d.get('port'),
 8125            port_override=d.get('port_override'),
 8126            secret_store_id=d.get('secret_store_id'),
 8127            tags=d.get('tags'),
 8128        )
 8129
 8130
 8131class NeptuneIAM:
 8132    '''
 8133
 8134    '''
 8135    __slots__ = [
 8136        'access_key',
 8137        'egress_filter',
 8138        'endpoint',
 8139        'healthy',
 8140        'id',
 8141        'name',
 8142        'port',
 8143        'port_override',
 8144        'region',
 8145        'role_arn',
 8146        'role_external_id',
 8147        'secret_access_key',
 8148        'secret_store_id',
 8149        'tags',
 8150    ]
 8151
 8152    def __init__(
 8153        self,
 8154        access_key=None,
 8155        egress_filter=None,
 8156        endpoint=None,
 8157        healthy=None,
 8158        id=None,
 8159        name=None,
 8160        port=None,
 8161        port_override=None,
 8162        region=None,
 8163        role_arn=None,
 8164        role_external_id=None,
 8165        secret_access_key=None,
 8166        secret_store_id=None,
 8167        tags=None,
 8168    ):
 8169        self.access_key = access_key if access_key is not None else ''
 8170        '''
 8171
 8172        '''
 8173        self.egress_filter = egress_filter if egress_filter is not None else ''
 8174        '''
 8175         A filter applied to the routing logic to pin datasource to nodes.
 8176        '''
 8177        self.endpoint = endpoint if endpoint is not None else ''
 8178        '''
 8179
 8180        '''
 8181        self.healthy = healthy if healthy is not None else False
 8182        '''
 8183         True if the datasource is reachable and the credentials are valid.
 8184        '''
 8185        self.id = id if id is not None else ''
 8186        '''
 8187         Unique identifier of the Resource.
 8188        '''
 8189        self.name = name if name is not None else ''
 8190        '''
 8191         Unique human-readable name of the Resource.
 8192        '''
 8193        self.port = port if port is not None else 0
 8194        '''
 8195
 8196        '''
 8197        self.port_override = port_override if port_override is not None else 0
 8198        '''
 8199
 8200        '''
 8201        self.region = region if region is not None else ''
 8202        '''
 8203
 8204        '''
 8205        self.role_arn = role_arn if role_arn is not None else ''
 8206        '''
 8207
 8208        '''
 8209        self.role_external_id = role_external_id if role_external_id is not None else ''
 8210        '''
 8211
 8212        '''
 8213        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8214        '''
 8215
 8216        '''
 8217        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8218        '''
 8219         ID of the secret store containing credentials for this resource, if any.
 8220        '''
 8221        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8222        '''
 8223         Tags is a map of key, value pairs.
 8224        '''
 8225
 8226    def __repr__(self):
 8227        return '<sdm.NeptuneIAM ' + \
 8228            'access_key: ' + repr(self.access_key) + ' ' +\
 8229            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8230            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8231            'healthy: ' + repr(self.healthy) + ' ' +\
 8232            'id: ' + repr(self.id) + ' ' +\
 8233            'name: ' + repr(self.name) + ' ' +\
 8234            'port: ' + repr(self.port) + ' ' +\
 8235            'port_override: ' + repr(self.port_override) + ' ' +\
 8236            'region: ' + repr(self.region) + ' ' +\
 8237            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8238            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8239            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8240            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8241            'tags: ' + repr(self.tags) + ' ' +\
 8242            '>'
 8243
 8244    def to_dict(self):
 8245        return {
 8246            'access_key': self.access_key,
 8247            'egress_filter': self.egress_filter,
 8248            'endpoint': self.endpoint,
 8249            'healthy': self.healthy,
 8250            'id': self.id,
 8251            'name': self.name,
 8252            'port': self.port,
 8253            'port_override': self.port_override,
 8254            'region': self.region,
 8255            'role_arn': self.role_arn,
 8256            'role_external_id': self.role_external_id,
 8257            'secret_access_key': self.secret_access_key,
 8258            'secret_store_id': self.secret_store_id,
 8259            'tags': self.tags,
 8260        }
 8261
 8262    @classmethod
 8263    def from_dict(cls, d):
 8264        return cls(
 8265            access_key=d.get('access_key'),
 8266            egress_filter=d.get('egress_filter'),
 8267            endpoint=d.get('endpoint'),
 8268            healthy=d.get('healthy'),
 8269            id=d.get('id'),
 8270            name=d.get('name'),
 8271            port=d.get('port'),
 8272            port_override=d.get('port_override'),
 8273            region=d.get('region'),
 8274            role_arn=d.get('role_arn'),
 8275            role_external_id=d.get('role_external_id'),
 8276            secret_access_key=d.get('secret_access_key'),
 8277            secret_store_id=d.get('secret_store_id'),
 8278            tags=d.get('tags'),
 8279        )
 8280
 8281
 8282class NodeCreateResponse:
 8283    '''
 8284     NodeCreateResponse reports how the Nodes were created in the system.
 8285    '''
 8286    __slots__ = [
 8287        'meta',
 8288        'node',
 8289        'rate_limit',
 8290        'token',
 8291    ]
 8292
 8293    def __init__(
 8294        self,
 8295        meta=None,
 8296        node=None,
 8297        rate_limit=None,
 8298        token=None,
 8299    ):
 8300        self.meta = meta if meta is not None else None
 8301        '''
 8302         Reserved for future use.
 8303        '''
 8304        self.node = node if node is not None else None
 8305        '''
 8306         The created Node.
 8307        '''
 8308        self.rate_limit = rate_limit if rate_limit is not None else None
 8309        '''
 8310         Rate limit information.
 8311        '''
 8312        self.token = token if token is not None else ''
 8313        '''
 8314         The auth token generated for the Node. The Node will use this token to
 8315         authenticate with the strongDM API.
 8316        '''
 8317
 8318    def __repr__(self):
 8319        return '<sdm.NodeCreateResponse ' + \
 8320            'meta: ' + repr(self.meta) + ' ' +\
 8321            'node: ' + repr(self.node) + ' ' +\
 8322            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8323            'token: ' + repr(self.token) + ' ' +\
 8324            '>'
 8325
 8326    def to_dict(self):
 8327        return {
 8328            'meta': self.meta,
 8329            'node': self.node,
 8330            'rate_limit': self.rate_limit,
 8331            'token': self.token,
 8332        }
 8333
 8334    @classmethod
 8335    def from_dict(cls, d):
 8336        return cls(
 8337            meta=d.get('meta'),
 8338            node=d.get('node'),
 8339            rate_limit=d.get('rate_limit'),
 8340            token=d.get('token'),
 8341        )
 8342
 8343
 8344class NodeDeleteResponse:
 8345    '''
 8346     NodeDeleteResponse returns information about a Node that was deleted.
 8347    '''
 8348    __slots__ = [
 8349        'meta',
 8350        'rate_limit',
 8351    ]
 8352
 8353    def __init__(
 8354        self,
 8355        meta=None,
 8356        rate_limit=None,
 8357    ):
 8358        self.meta = meta if meta is not None else None
 8359        '''
 8360         Reserved for future use.
 8361        '''
 8362        self.rate_limit = rate_limit if rate_limit is not None else None
 8363        '''
 8364         Rate limit information.
 8365        '''
 8366
 8367    def __repr__(self):
 8368        return '<sdm.NodeDeleteResponse ' + \
 8369            'meta: ' + repr(self.meta) + ' ' +\
 8370            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8371            '>'
 8372
 8373    def to_dict(self):
 8374        return {
 8375            'meta': self.meta,
 8376            'rate_limit': self.rate_limit,
 8377        }
 8378
 8379    @classmethod
 8380    def from_dict(cls, d):
 8381        return cls(
 8382            meta=d.get('meta'),
 8383            rate_limit=d.get('rate_limit'),
 8384        )
 8385
 8386
 8387class NodeGetResponse:
 8388    '''
 8389     NodeGetResponse returns a requested Node.
 8390    '''
 8391    __slots__ = [
 8392        'meta',
 8393        'node',
 8394        'rate_limit',
 8395    ]
 8396
 8397    def __init__(
 8398        self,
 8399        meta=None,
 8400        node=None,
 8401        rate_limit=None,
 8402    ):
 8403        self.meta = meta if meta is not None else None
 8404        '''
 8405         Reserved for future use.
 8406        '''
 8407        self.node = node if node is not None else None
 8408        '''
 8409         The requested Node.
 8410        '''
 8411        self.rate_limit = rate_limit if rate_limit is not None else None
 8412        '''
 8413         Rate limit information.
 8414        '''
 8415
 8416    def __repr__(self):
 8417        return '<sdm.NodeGetResponse ' + \
 8418            'meta: ' + repr(self.meta) + ' ' +\
 8419            'node: ' + repr(self.node) + ' ' +\
 8420            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8421            '>'
 8422
 8423    def to_dict(self):
 8424        return {
 8425            'meta': self.meta,
 8426            'node': self.node,
 8427            'rate_limit': self.rate_limit,
 8428        }
 8429
 8430    @classmethod
 8431    def from_dict(cls, d):
 8432        return cls(
 8433            meta=d.get('meta'),
 8434            node=d.get('node'),
 8435            rate_limit=d.get('rate_limit'),
 8436        )
 8437
 8438
 8439class NodeUpdateResponse:
 8440    '''
 8441     NodeUpdateResponse returns the fields of a Node after it has been updated by
 8442     a NodeUpdateRequest.
 8443    '''
 8444    __slots__ = [
 8445        'meta',
 8446        'node',
 8447        'rate_limit',
 8448    ]
 8449
 8450    def __init__(
 8451        self,
 8452        meta=None,
 8453        node=None,
 8454        rate_limit=None,
 8455    ):
 8456        self.meta = meta if meta is not None else None
 8457        '''
 8458         Reserved for future use.
 8459        '''
 8460        self.node = node if node is not None else None
 8461        '''
 8462         The updated Node.
 8463        '''
 8464        self.rate_limit = rate_limit if rate_limit is not None else None
 8465        '''
 8466         Rate limit information.
 8467        '''
 8468
 8469    def __repr__(self):
 8470        return '<sdm.NodeUpdateResponse ' + \
 8471            'meta: ' + repr(self.meta) + ' ' +\
 8472            'node: ' + repr(self.node) + ' ' +\
 8473            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8474            '>'
 8475
 8476    def to_dict(self):
 8477        return {
 8478            'meta': self.meta,
 8479            'node': self.node,
 8480            'rate_limit': self.rate_limit,
 8481        }
 8482
 8483    @classmethod
 8484    def from_dict(cls, d):
 8485        return cls(
 8486            meta=d.get('meta'),
 8487            node=d.get('node'),
 8488            rate_limit=d.get('rate_limit'),
 8489        )
 8490
 8491
 8492class Oracle:
 8493    '''
 8494
 8495    '''
 8496    __slots__ = [
 8497        'database',
 8498        'egress_filter',
 8499        'healthy',
 8500        'hostname',
 8501        'id',
 8502        'name',
 8503        'password',
 8504        'port',
 8505        'port_override',
 8506        'secret_store_id',
 8507        'tags',
 8508        'tls_required',
 8509        'username',
 8510    ]
 8511
 8512    def __init__(
 8513        self,
 8514        database=None,
 8515        egress_filter=None,
 8516        healthy=None,
 8517        hostname=None,
 8518        id=None,
 8519        name=None,
 8520        password=None,
 8521        port=None,
 8522        port_override=None,
 8523        secret_store_id=None,
 8524        tags=None,
 8525        tls_required=None,
 8526        username=None,
 8527    ):
 8528        self.database = database if database is not None else ''
 8529        '''
 8530
 8531        '''
 8532        self.egress_filter = egress_filter if egress_filter is not None else ''
 8533        '''
 8534         A filter applied to the routing logic to pin datasource to nodes.
 8535        '''
 8536        self.healthy = healthy if healthy is not None else False
 8537        '''
 8538         True if the datasource is reachable and the credentials are valid.
 8539        '''
 8540        self.hostname = hostname if hostname is not None else ''
 8541        '''
 8542
 8543        '''
 8544        self.id = id if id is not None else ''
 8545        '''
 8546         Unique identifier of the Resource.
 8547        '''
 8548        self.name = name if name is not None else ''
 8549        '''
 8550         Unique human-readable name of the Resource.
 8551        '''
 8552        self.password = password if password is not None else ''
 8553        '''
 8554
 8555        '''
 8556        self.port = port if port is not None else 0
 8557        '''
 8558
 8559        '''
 8560        self.port_override = port_override if port_override is not None else 0
 8561        '''
 8562
 8563        '''
 8564        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8565        '''
 8566         ID of the secret store containing credentials for this resource, if any.
 8567        '''
 8568        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8569        '''
 8570         Tags is a map of key, value pairs.
 8571        '''
 8572        self.tls_required = tls_required if tls_required is not None else False
 8573        '''
 8574
 8575        '''
 8576        self.username = username if username is not None else ''
 8577        '''
 8578
 8579        '''
 8580
 8581    def __repr__(self):
 8582        return '<sdm.Oracle ' + \
 8583            'database: ' + repr(self.database) + ' ' +\
 8584            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8585            'healthy: ' + repr(self.healthy) + ' ' +\
 8586            'hostname: ' + repr(self.hostname) + ' ' +\
 8587            'id: ' + repr(self.id) + ' ' +\
 8588            'name: ' + repr(self.name) + ' ' +\
 8589            'password: ' + repr(self.password) + ' ' +\
 8590            'port: ' + repr(self.port) + ' ' +\
 8591            'port_override: ' + repr(self.port_override) + ' ' +\
 8592            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8593            'tags: ' + repr(self.tags) + ' ' +\
 8594            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8595            'username: ' + repr(self.username) + ' ' +\
 8596            '>'
 8597
 8598    def to_dict(self):
 8599        return {
 8600            'database': self.database,
 8601            'egress_filter': self.egress_filter,
 8602            'healthy': self.healthy,
 8603            'hostname': self.hostname,
 8604            'id': self.id,
 8605            'name': self.name,
 8606            'password': self.password,
 8607            'port': self.port,
 8608            'port_override': self.port_override,
 8609            'secret_store_id': self.secret_store_id,
 8610            'tags': self.tags,
 8611            'tls_required': self.tls_required,
 8612            'username': self.username,
 8613        }
 8614
 8615    @classmethod
 8616    def from_dict(cls, d):
 8617        return cls(
 8618            database=d.get('database'),
 8619            egress_filter=d.get('egress_filter'),
 8620            healthy=d.get('healthy'),
 8621            hostname=d.get('hostname'),
 8622            id=d.get('id'),
 8623            name=d.get('name'),
 8624            password=d.get('password'),
 8625            port=d.get('port'),
 8626            port_override=d.get('port_override'),
 8627            secret_store_id=d.get('secret_store_id'),
 8628            tags=d.get('tags'),
 8629            tls_required=d.get('tls_required'),
 8630            username=d.get('username'),
 8631        )
 8632
 8633
 8634class Postgres:
 8635    '''
 8636
 8637    '''
 8638    __slots__ = [
 8639        'database',
 8640        'egress_filter',
 8641        'healthy',
 8642        'hostname',
 8643        'id',
 8644        'name',
 8645        'override_database',
 8646        'password',
 8647        'port',
 8648        'port_override',
 8649        'secret_store_id',
 8650        'tags',
 8651        'username',
 8652    ]
 8653
 8654    def __init__(
 8655        self,
 8656        database=None,
 8657        egress_filter=None,
 8658        healthy=None,
 8659        hostname=None,
 8660        id=None,
 8661        name=None,
 8662        override_database=None,
 8663        password=None,
 8664        port=None,
 8665        port_override=None,
 8666        secret_store_id=None,
 8667        tags=None,
 8668        username=None,
 8669    ):
 8670        self.database = database if database is not None else ''
 8671        '''
 8672
 8673        '''
 8674        self.egress_filter = egress_filter if egress_filter is not None else ''
 8675        '''
 8676         A filter applied to the routing logic to pin datasource to nodes.
 8677        '''
 8678        self.healthy = healthy if healthy is not None else False
 8679        '''
 8680         True if the datasource is reachable and the credentials are valid.
 8681        '''
 8682        self.hostname = hostname if hostname is not None else ''
 8683        '''
 8684
 8685        '''
 8686        self.id = id if id is not None else ''
 8687        '''
 8688         Unique identifier of the Resource.
 8689        '''
 8690        self.name = name if name is not None else ''
 8691        '''
 8692         Unique human-readable name of the Resource.
 8693        '''
 8694        self.override_database = override_database if override_database is not None else False
 8695        '''
 8696
 8697        '''
 8698        self.password = password if password is not None else ''
 8699        '''
 8700
 8701        '''
 8702        self.port = port if port is not None else 0
 8703        '''
 8704
 8705        '''
 8706        self.port_override = port_override if port_override is not None else 0
 8707        '''
 8708
 8709        '''
 8710        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8711        '''
 8712         ID of the secret store containing credentials for this resource, if any.
 8713        '''
 8714        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8715        '''
 8716         Tags is a map of key, value pairs.
 8717        '''
 8718        self.username = username if username is not None else ''
 8719        '''
 8720
 8721        '''
 8722
 8723    def __repr__(self):
 8724        return '<sdm.Postgres ' + \
 8725            'database: ' + repr(self.database) + ' ' +\
 8726            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8727            'healthy: ' + repr(self.healthy) + ' ' +\
 8728            'hostname: ' + repr(self.hostname) + ' ' +\
 8729            'id: ' + repr(self.id) + ' ' +\
 8730            'name: ' + repr(self.name) + ' ' +\
 8731            'override_database: ' + repr(self.override_database) + ' ' +\
 8732            'password: ' + repr(self.password) + ' ' +\
 8733            'port: ' + repr(self.port) + ' ' +\
 8734            'port_override: ' + repr(self.port_override) + ' ' +\
 8735            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8736            'tags: ' + repr(self.tags) + ' ' +\
 8737            'username: ' + repr(self.username) + ' ' +\
 8738            '>'
 8739
 8740    def to_dict(self):
 8741        return {
 8742            'database': self.database,
 8743            'egress_filter': self.egress_filter,
 8744            'healthy': self.healthy,
 8745            'hostname': self.hostname,
 8746            'id': self.id,
 8747            'name': self.name,
 8748            'override_database': self.override_database,
 8749            'password': self.password,
 8750            'port': self.port,
 8751            'port_override': self.port_override,
 8752            'secret_store_id': self.secret_store_id,
 8753            'tags': self.tags,
 8754            'username': self.username,
 8755        }
 8756
 8757    @classmethod
 8758    def from_dict(cls, d):
 8759        return cls(
 8760            database=d.get('database'),
 8761            egress_filter=d.get('egress_filter'),
 8762            healthy=d.get('healthy'),
 8763            hostname=d.get('hostname'),
 8764            id=d.get('id'),
 8765            name=d.get('name'),
 8766            override_database=d.get('override_database'),
 8767            password=d.get('password'),
 8768            port=d.get('port'),
 8769            port_override=d.get('port_override'),
 8770            secret_store_id=d.get('secret_store_id'),
 8771            tags=d.get('tags'),
 8772            username=d.get('username'),
 8773        )
 8774
 8775
 8776class Presto:
 8777    '''
 8778
 8779    '''
 8780    __slots__ = [
 8781        'database',
 8782        'egress_filter',
 8783        'healthy',
 8784        'hostname',
 8785        'id',
 8786        'name',
 8787        'password',
 8788        'port',
 8789        'port_override',
 8790        'secret_store_id',
 8791        'tags',
 8792        'tls_required',
 8793        'username',
 8794    ]
 8795
 8796    def __init__(
 8797        self,
 8798        database=None,
 8799        egress_filter=None,
 8800        healthy=None,
 8801        hostname=None,
 8802        id=None,
 8803        name=None,
 8804        password=None,
 8805        port=None,
 8806        port_override=None,
 8807        secret_store_id=None,
 8808        tags=None,
 8809        tls_required=None,
 8810        username=None,
 8811    ):
 8812        self.database = database if database is not None else ''
 8813        '''
 8814
 8815        '''
 8816        self.egress_filter = egress_filter if egress_filter is not None else ''
 8817        '''
 8818         A filter applied to the routing logic to pin datasource to nodes.
 8819        '''
 8820        self.healthy = healthy if healthy is not None else False
 8821        '''
 8822         True if the datasource is reachable and the credentials are valid.
 8823        '''
 8824        self.hostname = hostname if hostname is not None else ''
 8825        '''
 8826
 8827        '''
 8828        self.id = id if id is not None else ''
 8829        '''
 8830         Unique identifier of the Resource.
 8831        '''
 8832        self.name = name if name is not None else ''
 8833        '''
 8834         Unique human-readable name of the Resource.
 8835        '''
 8836        self.password = password if password is not None else ''
 8837        '''
 8838
 8839        '''
 8840        self.port = port if port is not None else 0
 8841        '''
 8842
 8843        '''
 8844        self.port_override = port_override if port_override is not None else 0
 8845        '''
 8846
 8847        '''
 8848        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8849        '''
 8850         ID of the secret store containing credentials for this resource, if any.
 8851        '''
 8852        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8853        '''
 8854         Tags is a map of key, value pairs.
 8855        '''
 8856        self.tls_required = tls_required if tls_required is not None else False
 8857        '''
 8858
 8859        '''
 8860        self.username = username if username is not None else ''
 8861        '''
 8862
 8863        '''
 8864
 8865    def __repr__(self):
 8866        return '<sdm.Presto ' + \
 8867            'database: ' + repr(self.database) + ' ' +\
 8868            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8869            'healthy: ' + repr(self.healthy) + ' ' +\
 8870            'hostname: ' + repr(self.hostname) + ' ' +\
 8871            'id: ' + repr(self.id) + ' ' +\
 8872            'name: ' + repr(self.name) + ' ' +\
 8873            'password: ' + repr(self.password) + ' ' +\
 8874            'port: ' + repr(self.port) + ' ' +\
 8875            'port_override: ' + repr(self.port_override) + ' ' +\
 8876            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8877            'tags: ' + repr(self.tags) + ' ' +\
 8878            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8879            'username: ' + repr(self.username) + ' ' +\
 8880            '>'
 8881
 8882    def to_dict(self):
 8883        return {
 8884            'database': self.database,
 8885            'egress_filter': self.egress_filter,
 8886            'healthy': self.healthy,
 8887            'hostname': self.hostname,
 8888            'id': self.id,
 8889            'name': self.name,
 8890            'password': self.password,
 8891            'port': self.port,
 8892            'port_override': self.port_override,
 8893            'secret_store_id': self.secret_store_id,
 8894            'tags': self.tags,
 8895            'tls_required': self.tls_required,
 8896            'username': self.username,
 8897        }
 8898
 8899    @classmethod
 8900    def from_dict(cls, d):
 8901        return cls(
 8902            database=d.get('database'),
 8903            egress_filter=d.get('egress_filter'),
 8904            healthy=d.get('healthy'),
 8905            hostname=d.get('hostname'),
 8906            id=d.get('id'),
 8907            name=d.get('name'),
 8908            password=d.get('password'),
 8909            port=d.get('port'),
 8910            port_override=d.get('port_override'),
 8911            secret_store_id=d.get('secret_store_id'),
 8912            tags=d.get('tags'),
 8913            tls_required=d.get('tls_required'),
 8914            username=d.get('username'),
 8915        )
 8916
 8917
 8918class RDP:
 8919    '''
 8920
 8921    '''
 8922    __slots__ = [
 8923        'downgrade_nla_connections',
 8924        'egress_filter',
 8925        'healthy',
 8926        'hostname',
 8927        'id',
 8928        'name',
 8929        'password',
 8930        'port',
 8931        'port_override',
 8932        'secret_store_id',
 8933        'tags',
 8934        'username',
 8935    ]
 8936
 8937    def __init__(
 8938        self,
 8939        downgrade_nla_connections=None,
 8940        egress_filter=None,
 8941        healthy=None,
 8942        hostname=None,
 8943        id=None,
 8944        name=None,
 8945        password=None,
 8946        port=None,
 8947        port_override=None,
 8948        secret_store_id=None,
 8949        tags=None,
 8950        username=None,
 8951    ):
 8952        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 8953        '''
 8954
 8955        '''
 8956        self.egress_filter = egress_filter if egress_filter is not None else ''
 8957        '''
 8958         A filter applied to the routing logic to pin datasource to nodes.
 8959        '''
 8960        self.healthy = healthy if healthy is not None else False
 8961        '''
 8962         True if the datasource is reachable and the credentials are valid.
 8963        '''
 8964        self.hostname = hostname if hostname is not None else ''
 8965        '''
 8966
 8967        '''
 8968        self.id = id if id is not None else ''
 8969        '''
 8970         Unique identifier of the Resource.
 8971        '''
 8972        self.name = name if name is not None else ''
 8973        '''
 8974         Unique human-readable name of the Resource.
 8975        '''
 8976        self.password = password if password is not None else ''
 8977        '''
 8978
 8979        '''
 8980        self.port = port if port is not None else 0
 8981        '''
 8982
 8983        '''
 8984        self.port_override = port_override if port_override is not None else 0
 8985        '''
 8986
 8987        '''
 8988        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8989        '''
 8990         ID of the secret store containing credentials for this resource, if any.
 8991        '''
 8992        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8993        '''
 8994         Tags is a map of key, value pairs.
 8995        '''
 8996        self.username = username if username is not None else ''
 8997        '''
 8998
 8999        '''
 9000
 9001    def __repr__(self):
 9002        return '<sdm.RDP ' + \
 9003            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9004            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9005            'healthy: ' + repr(self.healthy) + ' ' +\
 9006            'hostname: ' + repr(self.hostname) + ' ' +\
 9007            'id: ' + repr(self.id) + ' ' +\
 9008            'name: ' + repr(self.name) + ' ' +\
 9009            'password: ' + repr(self.password) + ' ' +\
 9010            'port: ' + repr(self.port) + ' ' +\
 9011            'port_override: ' + repr(self.port_override) + ' ' +\
 9012            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9013            'tags: ' + repr(self.tags) + ' ' +\
 9014            'username: ' + repr(self.username) + ' ' +\
 9015            '>'
 9016
 9017    def to_dict(self):
 9018        return {
 9019            'downgrade_nla_connections': self.downgrade_nla_connections,
 9020            'egress_filter': self.egress_filter,
 9021            'healthy': self.healthy,
 9022            'hostname': self.hostname,
 9023            'id': self.id,
 9024            'name': self.name,
 9025            'password': self.password,
 9026            'port': self.port,
 9027            'port_override': self.port_override,
 9028            'secret_store_id': self.secret_store_id,
 9029            'tags': self.tags,
 9030            'username': self.username,
 9031        }
 9032
 9033    @classmethod
 9034    def from_dict(cls, d):
 9035        return cls(
 9036            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9037            egress_filter=d.get('egress_filter'),
 9038            healthy=d.get('healthy'),
 9039            hostname=d.get('hostname'),
 9040            id=d.get('id'),
 9041            name=d.get('name'),
 9042            password=d.get('password'),
 9043            port=d.get('port'),
 9044            port_override=d.get('port_override'),
 9045            secret_store_id=d.get('secret_store_id'),
 9046            tags=d.get('tags'),
 9047            username=d.get('username'),
 9048        )
 9049
 9050
 9051class RabbitMQAMQP091:
 9052    '''
 9053
 9054    '''
 9055    __slots__ = [
 9056        'egress_filter',
 9057        'healthy',
 9058        'hostname',
 9059        'id',
 9060        'name',
 9061        'password',
 9062        'port',
 9063        'port_override',
 9064        'secret_store_id',
 9065        'tags',
 9066        'tls_required',
 9067        'username',
 9068    ]
 9069
 9070    def __init__(
 9071        self,
 9072        egress_filter=None,
 9073        healthy=None,
 9074        hostname=None,
 9075        id=None,
 9076        name=None,
 9077        password=None,
 9078        port=None,
 9079        port_override=None,
 9080        secret_store_id=None,
 9081        tags=None,
 9082        tls_required=None,
 9083        username=None,
 9084    ):
 9085        self.egress_filter = egress_filter if egress_filter is not None else ''
 9086        '''
 9087         A filter applied to the routing logic to pin datasource to nodes.
 9088        '''
 9089        self.healthy = healthy if healthy is not None else False
 9090        '''
 9091         True if the datasource is reachable and the credentials are valid.
 9092        '''
 9093        self.hostname = hostname if hostname is not None else ''
 9094        '''
 9095
 9096        '''
 9097        self.id = id if id is not None else ''
 9098        '''
 9099         Unique identifier of the Resource.
 9100        '''
 9101        self.name = name if name is not None else ''
 9102        '''
 9103         Unique human-readable name of the Resource.
 9104        '''
 9105        self.password = password if password is not None else ''
 9106        '''
 9107
 9108        '''
 9109        self.port = port if port is not None else 0
 9110        '''
 9111
 9112        '''
 9113        self.port_override = port_override if port_override is not None else 0
 9114        '''
 9115
 9116        '''
 9117        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9118        '''
 9119         ID of the secret store containing credentials for this resource, if any.
 9120        '''
 9121        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9122        '''
 9123         Tags is a map of key, value pairs.
 9124        '''
 9125        self.tls_required = tls_required if tls_required is not None else False
 9126        '''
 9127
 9128        '''
 9129        self.username = username if username is not None else ''
 9130        '''
 9131
 9132        '''
 9133
 9134    def __repr__(self):
 9135        return '<sdm.RabbitMQAMQP091 ' + \
 9136            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9137            'healthy: ' + repr(self.healthy) + ' ' +\
 9138            'hostname: ' + repr(self.hostname) + ' ' +\
 9139            'id: ' + repr(self.id) + ' ' +\
 9140            'name: ' + repr(self.name) + ' ' +\
 9141            'password: ' + repr(self.password) + ' ' +\
 9142            'port: ' + repr(self.port) + ' ' +\
 9143            'port_override: ' + repr(self.port_override) + ' ' +\
 9144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9145            'tags: ' + repr(self.tags) + ' ' +\
 9146            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9147            'username: ' + repr(self.username) + ' ' +\
 9148            '>'
 9149
 9150    def to_dict(self):
 9151        return {
 9152            'egress_filter': self.egress_filter,
 9153            'healthy': self.healthy,
 9154            'hostname': self.hostname,
 9155            'id': self.id,
 9156            'name': self.name,
 9157            'password': self.password,
 9158            'port': self.port,
 9159            'port_override': self.port_override,
 9160            'secret_store_id': self.secret_store_id,
 9161            'tags': self.tags,
 9162            'tls_required': self.tls_required,
 9163            'username': self.username,
 9164        }
 9165
 9166    @classmethod
 9167    def from_dict(cls, d):
 9168        return cls(
 9169            egress_filter=d.get('egress_filter'),
 9170            healthy=d.get('healthy'),
 9171            hostname=d.get('hostname'),
 9172            id=d.get('id'),
 9173            name=d.get('name'),
 9174            password=d.get('password'),
 9175            port=d.get('port'),
 9176            port_override=d.get('port_override'),
 9177            secret_store_id=d.get('secret_store_id'),
 9178            tags=d.get('tags'),
 9179            tls_required=d.get('tls_required'),
 9180            username=d.get('username'),
 9181        )
 9182
 9183
 9184class RateLimitMetadata:
 9185    '''
 9186     RateLimitMetadata contains information about remaining requests avaialable
 9187     to the user over some timeframe.
 9188    '''
 9189    __slots__ = [
 9190        'bucket',
 9191        'limit',
 9192        'remaining',
 9193        'reset_at',
 9194    ]
 9195
 9196    def __init__(
 9197        self,
 9198        bucket=None,
 9199        limit=None,
 9200        remaining=None,
 9201        reset_at=None,
 9202    ):
 9203        self.bucket = bucket if bucket is not None else ''
 9204        '''
 9205         The bucket this user/token is associated with, which may be shared between
 9206         multiple users/tokens.
 9207        '''
 9208        self.limit = limit if limit is not None else 0
 9209        '''
 9210         How many total requests the user/token is authorized to make before being
 9211         rate limited.
 9212        '''
 9213        self.remaining = remaining if remaining is not None else 0
 9214        '''
 9215         How many remaining requests out of the limit are still avaialable.
 9216        '''
 9217        self.reset_at = reset_at if reset_at is not None else None
 9218        '''
 9219         The time when remaining will be reset to limit.
 9220        '''
 9221
 9222    def __repr__(self):
 9223        return '<sdm.RateLimitMetadata ' + \
 9224            'bucket: ' + repr(self.bucket) + ' ' +\
 9225            'limit: ' + repr(self.limit) + ' ' +\
 9226            'remaining: ' + repr(self.remaining) + ' ' +\
 9227            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9228            '>'
 9229
 9230    def to_dict(self):
 9231        return {
 9232            'bucket': self.bucket,
 9233            'limit': self.limit,
 9234            'remaining': self.remaining,
 9235            'reset_at': self.reset_at,
 9236        }
 9237
 9238    @classmethod
 9239    def from_dict(cls, d):
 9240        return cls(
 9241            bucket=d.get('bucket'),
 9242            limit=d.get('limit'),
 9243            remaining=d.get('remaining'),
 9244            reset_at=d.get('reset_at'),
 9245        )
 9246
 9247
 9248class RawTCP:
 9249    '''
 9250
 9251    '''
 9252    __slots__ = [
 9253        'egress_filter',
 9254        'healthy',
 9255        'hostname',
 9256        'id',
 9257        'name',
 9258        'port',
 9259        'port_override',
 9260        'secret_store_id',
 9261        'tags',
 9262    ]
 9263
 9264    def __init__(
 9265        self,
 9266        egress_filter=None,
 9267        healthy=None,
 9268        hostname=None,
 9269        id=None,
 9270        name=None,
 9271        port=None,
 9272        port_override=None,
 9273        secret_store_id=None,
 9274        tags=None,
 9275    ):
 9276        self.egress_filter = egress_filter if egress_filter is not None else ''
 9277        '''
 9278         A filter applied to the routing logic to pin datasource to nodes.
 9279        '''
 9280        self.healthy = healthy if healthy is not None else False
 9281        '''
 9282         True if the datasource is reachable and the credentials are valid.
 9283        '''
 9284        self.hostname = hostname if hostname is not None else ''
 9285        '''
 9286
 9287        '''
 9288        self.id = id if id is not None else ''
 9289        '''
 9290         Unique identifier of the Resource.
 9291        '''
 9292        self.name = name if name is not None else ''
 9293        '''
 9294         Unique human-readable name of the Resource.
 9295        '''
 9296        self.port = port if port is not None else 0
 9297        '''
 9298
 9299        '''
 9300        self.port_override = port_override if port_override is not None else 0
 9301        '''
 9302
 9303        '''
 9304        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9305        '''
 9306         ID of the secret store containing credentials for this resource, if any.
 9307        '''
 9308        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9309        '''
 9310         Tags is a map of key, value pairs.
 9311        '''
 9312
 9313    def __repr__(self):
 9314        return '<sdm.RawTCP ' + \
 9315            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9316            'healthy: ' + repr(self.healthy) + ' ' +\
 9317            'hostname: ' + repr(self.hostname) + ' ' +\
 9318            'id: ' + repr(self.id) + ' ' +\
 9319            'name: ' + repr(self.name) + ' ' +\
 9320            'port: ' + repr(self.port) + ' ' +\
 9321            'port_override: ' + repr(self.port_override) + ' ' +\
 9322            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9323            'tags: ' + repr(self.tags) + ' ' +\
 9324            '>'
 9325
 9326    def to_dict(self):
 9327        return {
 9328            'egress_filter': self.egress_filter,
 9329            'healthy': self.healthy,
 9330            'hostname': self.hostname,
 9331            'id': self.id,
 9332            'name': self.name,
 9333            'port': self.port,
 9334            'port_override': self.port_override,
 9335            'secret_store_id': self.secret_store_id,
 9336            'tags': self.tags,
 9337        }
 9338
 9339    @classmethod
 9340    def from_dict(cls, d):
 9341        return cls(
 9342            egress_filter=d.get('egress_filter'),
 9343            healthy=d.get('healthy'),
 9344            hostname=d.get('hostname'),
 9345            id=d.get('id'),
 9346            name=d.get('name'),
 9347            port=d.get('port'),
 9348            port_override=d.get('port_override'),
 9349            secret_store_id=d.get('secret_store_id'),
 9350            tags=d.get('tags'),
 9351        )
 9352
 9353
 9354class Redis:
 9355    '''
 9356
 9357    '''
 9358    __slots__ = [
 9359        'egress_filter',
 9360        'healthy',
 9361        'hostname',
 9362        'id',
 9363        'name',
 9364        'password',
 9365        'port',
 9366        'port_override',
 9367        'secret_store_id',
 9368        'tags',
 9369    ]
 9370
 9371    def __init__(
 9372        self,
 9373        egress_filter=None,
 9374        healthy=None,
 9375        hostname=None,
 9376        id=None,
 9377        name=None,
 9378        password=None,
 9379        port=None,
 9380        port_override=None,
 9381        secret_store_id=None,
 9382        tags=None,
 9383    ):
 9384        self.egress_filter = egress_filter if egress_filter is not None else ''
 9385        '''
 9386         A filter applied to the routing logic to pin datasource to nodes.
 9387        '''
 9388        self.healthy = healthy if healthy is not None else False
 9389        '''
 9390         True if the datasource is reachable and the credentials are valid.
 9391        '''
 9392        self.hostname = hostname if hostname is not None else ''
 9393        '''
 9394
 9395        '''
 9396        self.id = id if id is not None else ''
 9397        '''
 9398         Unique identifier of the Resource.
 9399        '''
 9400        self.name = name if name is not None else ''
 9401        '''
 9402         Unique human-readable name of the Resource.
 9403        '''
 9404        self.password = password if password is not None else ''
 9405        '''
 9406
 9407        '''
 9408        self.port = port if port is not None else 0
 9409        '''
 9410
 9411        '''
 9412        self.port_override = port_override if port_override is not None else 0
 9413        '''
 9414
 9415        '''
 9416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9417        '''
 9418         ID of the secret store containing credentials for this resource, if any.
 9419        '''
 9420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9421        '''
 9422         Tags is a map of key, value pairs.
 9423        '''
 9424
 9425    def __repr__(self):
 9426        return '<sdm.Redis ' + \
 9427            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9428            'healthy: ' + repr(self.healthy) + ' ' +\
 9429            'hostname: ' + repr(self.hostname) + ' ' +\
 9430            'id: ' + repr(self.id) + ' ' +\
 9431            'name: ' + repr(self.name) + ' ' +\
 9432            'password: ' + repr(self.password) + ' ' +\
 9433            'port: ' + repr(self.port) + ' ' +\
 9434            'port_override: ' + repr(self.port_override) + ' ' +\
 9435            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9436            'tags: ' + repr(self.tags) + ' ' +\
 9437            '>'
 9438
 9439    def to_dict(self):
 9440        return {
 9441            'egress_filter': self.egress_filter,
 9442            'healthy': self.healthy,
 9443            'hostname': self.hostname,
 9444            'id': self.id,
 9445            'name': self.name,
 9446            'password': self.password,
 9447            'port': self.port,
 9448            'port_override': self.port_override,
 9449            'secret_store_id': self.secret_store_id,
 9450            'tags': self.tags,
 9451        }
 9452
 9453    @classmethod
 9454    def from_dict(cls, d):
 9455        return cls(
 9456            egress_filter=d.get('egress_filter'),
 9457            healthy=d.get('healthy'),
 9458            hostname=d.get('hostname'),
 9459            id=d.get('id'),
 9460            name=d.get('name'),
 9461            password=d.get('password'),
 9462            port=d.get('port'),
 9463            port_override=d.get('port_override'),
 9464            secret_store_id=d.get('secret_store_id'),
 9465            tags=d.get('tags'),
 9466        )
 9467
 9468
 9469class Redshift:
 9470    '''
 9471
 9472    '''
 9473    __slots__ = [
 9474        'database',
 9475        'egress_filter',
 9476        'healthy',
 9477        'hostname',
 9478        'id',
 9479        'name',
 9480        'override_database',
 9481        'password',
 9482        'port',
 9483        'port_override',
 9484        'secret_store_id',
 9485        'tags',
 9486        'username',
 9487    ]
 9488
 9489    def __init__(
 9490        self,
 9491        database=None,
 9492        egress_filter=None,
 9493        healthy=None,
 9494        hostname=None,
 9495        id=None,
 9496        name=None,
 9497        override_database=None,
 9498        password=None,
 9499        port=None,
 9500        port_override=None,
 9501        secret_store_id=None,
 9502        tags=None,
 9503        username=None,
 9504    ):
 9505        self.database = database if database is not None else ''
 9506        '''
 9507
 9508        '''
 9509        self.egress_filter = egress_filter if egress_filter is not None else ''
 9510        '''
 9511         A filter applied to the routing logic to pin datasource to nodes.
 9512        '''
 9513        self.healthy = healthy if healthy is not None else False
 9514        '''
 9515         True if the datasource is reachable and the credentials are valid.
 9516        '''
 9517        self.hostname = hostname if hostname is not None else ''
 9518        '''
 9519
 9520        '''
 9521        self.id = id if id is not None else ''
 9522        '''
 9523         Unique identifier of the Resource.
 9524        '''
 9525        self.name = name if name is not None else ''
 9526        '''
 9527         Unique human-readable name of the Resource.
 9528        '''
 9529        self.override_database = override_database if override_database is not None else False
 9530        '''
 9531
 9532        '''
 9533        self.password = password if password is not None else ''
 9534        '''
 9535
 9536        '''
 9537        self.port = port if port is not None else 0
 9538        '''
 9539
 9540        '''
 9541        self.port_override = port_override if port_override is not None else 0
 9542        '''
 9543
 9544        '''
 9545        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9546        '''
 9547         ID of the secret store containing credentials for this resource, if any.
 9548        '''
 9549        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9550        '''
 9551         Tags is a map of key, value pairs.
 9552        '''
 9553        self.username = username if username is not None else ''
 9554        '''
 9555
 9556        '''
 9557
 9558    def __repr__(self):
 9559        return '<sdm.Redshift ' + \
 9560            'database: ' + repr(self.database) + ' ' +\
 9561            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9562            'healthy: ' + repr(self.healthy) + ' ' +\
 9563            'hostname: ' + repr(self.hostname) + ' ' +\
 9564            'id: ' + repr(self.id) + ' ' +\
 9565            'name: ' + repr(self.name) + ' ' +\
 9566            'override_database: ' + repr(self.override_database) + ' ' +\
 9567            'password: ' + repr(self.password) + ' ' +\
 9568            'port: ' + repr(self.port) + ' ' +\
 9569            'port_override: ' + repr(self.port_override) + ' ' +\
 9570            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9571            'tags: ' + repr(self.tags) + ' ' +\
 9572            'username: ' + repr(self.username) + ' ' +\
 9573            '>'
 9574
 9575    def to_dict(self):
 9576        return {
 9577            'database': self.database,
 9578            'egress_filter': self.egress_filter,
 9579            'healthy': self.healthy,
 9580            'hostname': self.hostname,
 9581            'id': self.id,
 9582            'name': self.name,
 9583            'override_database': self.override_database,
 9584            'password': self.password,
 9585            'port': self.port,
 9586            'port_override': self.port_override,
 9587            'secret_store_id': self.secret_store_id,
 9588            'tags': self.tags,
 9589            'username': self.username,
 9590        }
 9591
 9592    @classmethod
 9593    def from_dict(cls, d):
 9594        return cls(
 9595            database=d.get('database'),
 9596            egress_filter=d.get('egress_filter'),
 9597            healthy=d.get('healthy'),
 9598            hostname=d.get('hostname'),
 9599            id=d.get('id'),
 9600            name=d.get('name'),
 9601            override_database=d.get('override_database'),
 9602            password=d.get('password'),
 9603            port=d.get('port'),
 9604            port_override=d.get('port_override'),
 9605            secret_store_id=d.get('secret_store_id'),
 9606            tags=d.get('tags'),
 9607            username=d.get('username'),
 9608        )
 9609
 9610
 9611class Relay:
 9612    '''
 9613     Relay represents a StrongDM CLI installation running in relay mode.
 9614    '''
 9615    __slots__ = [
 9616        'gateway_filter',
 9617        'id',
 9618        'name',
 9619        'state',
 9620        'tags',
 9621    ]
 9622
 9623    def __init__(
 9624        self,
 9625        gateway_filter=None,
 9626        id=None,
 9627        name=None,
 9628        state=None,
 9629        tags=None,
 9630    ):
 9631        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9632        '''
 9633         GatewayFilter can be used to restrict the peering between relays and
 9634         gateways.
 9635        '''
 9636        self.id = id if id is not None else ''
 9637        '''
 9638         Unique identifier of the Relay.
 9639        '''
 9640        self.name = name if name is not None else ''
 9641        '''
 9642         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9643        '''
 9644        self.state = state if state is not None else ''
 9645        '''
 9646         The current state of the relay. One of: "new", "verifying_restart",
 9647         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9648         "unknown".
 9649        '''
 9650        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9651        '''
 9652         Tags is a map of key, value pairs.
 9653        '''
 9654
 9655    def __repr__(self):
 9656        return '<sdm.Relay ' + \
 9657            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9658            'id: ' + repr(self.id) + ' ' +\
 9659            'name: ' + repr(self.name) + ' ' +\
 9660            'state: ' + repr(self.state) + ' ' +\
 9661            'tags: ' + repr(self.tags) + ' ' +\
 9662            '>'
 9663
 9664    def to_dict(self):
 9665        return {
 9666            'gateway_filter': self.gateway_filter,
 9667            'id': self.id,
 9668            'name': self.name,
 9669            'state': self.state,
 9670            'tags': self.tags,
 9671        }
 9672
 9673    @classmethod
 9674    def from_dict(cls, d):
 9675        return cls(
 9676            gateway_filter=d.get('gateway_filter'),
 9677            id=d.get('id'),
 9678            name=d.get('name'),
 9679            state=d.get('state'),
 9680            tags=d.get('tags'),
 9681        )
 9682
 9683
 9684class ResourceCreateResponse:
 9685    '''
 9686     ResourceCreateResponse reports how the Resources were created in the system.
 9687    '''
 9688    __slots__ = [
 9689        'meta',
 9690        'rate_limit',
 9691        'resource',
 9692    ]
 9693
 9694    def __init__(
 9695        self,
 9696        meta=None,
 9697        rate_limit=None,
 9698        resource=None,
 9699    ):
 9700        self.meta = meta if meta is not None else None
 9701        '''
 9702         Reserved for future use.
 9703        '''
 9704        self.rate_limit = rate_limit if rate_limit is not None else None
 9705        '''
 9706         Rate limit information.
 9707        '''
 9708        self.resource = resource if resource is not None else None
 9709        '''
 9710         The created Resource.
 9711        '''
 9712
 9713    def __repr__(self):
 9714        return '<sdm.ResourceCreateResponse ' + \
 9715            'meta: ' + repr(self.meta) + ' ' +\
 9716            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9717            'resource: ' + repr(self.resource) + ' ' +\
 9718            '>'
 9719
 9720    def to_dict(self):
 9721        return {
 9722            'meta': self.meta,
 9723            'rate_limit': self.rate_limit,
 9724            'resource': self.resource,
 9725        }
 9726
 9727    @classmethod
 9728    def from_dict(cls, d):
 9729        return cls(
 9730            meta=d.get('meta'),
 9731            rate_limit=d.get('rate_limit'),
 9732            resource=d.get('resource'),
 9733        )
 9734
 9735
 9736class ResourceDeleteResponse:
 9737    '''
 9738     ResourceDeleteResponse returns information about a Resource that was deleted.
 9739    '''
 9740    __slots__ = [
 9741        'meta',
 9742        'rate_limit',
 9743    ]
 9744
 9745    def __init__(
 9746        self,
 9747        meta=None,
 9748        rate_limit=None,
 9749    ):
 9750        self.meta = meta if meta is not None else None
 9751        '''
 9752         Reserved for future use.
 9753        '''
 9754        self.rate_limit = rate_limit if rate_limit is not None else None
 9755        '''
 9756         Rate limit information.
 9757        '''
 9758
 9759    def __repr__(self):
 9760        return '<sdm.ResourceDeleteResponse ' + \
 9761            'meta: ' + repr(self.meta) + ' ' +\
 9762            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9763            '>'
 9764
 9765    def to_dict(self):
 9766        return {
 9767            'meta': self.meta,
 9768            'rate_limit': self.rate_limit,
 9769        }
 9770
 9771    @classmethod
 9772    def from_dict(cls, d):
 9773        return cls(
 9774            meta=d.get('meta'),
 9775            rate_limit=d.get('rate_limit'),
 9776        )
 9777
 9778
 9779class ResourceGetResponse:
 9780    '''
 9781     ResourceGetResponse returns a requested Resource.
 9782    '''
 9783    __slots__ = [
 9784        'meta',
 9785        'rate_limit',
 9786        'resource',
 9787    ]
 9788
 9789    def __init__(
 9790        self,
 9791        meta=None,
 9792        rate_limit=None,
 9793        resource=None,
 9794    ):
 9795        self.meta = meta if meta is not None else None
 9796        '''
 9797         Reserved for future use.
 9798        '''
 9799        self.rate_limit = rate_limit if rate_limit is not None else None
 9800        '''
 9801         Rate limit information.
 9802        '''
 9803        self.resource = resource if resource is not None else None
 9804        '''
 9805         The requested Resource.
 9806        '''
 9807
 9808    def __repr__(self):
 9809        return '<sdm.ResourceGetResponse ' + \
 9810            'meta: ' + repr(self.meta) + ' ' +\
 9811            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9812            'resource: ' + repr(self.resource) + ' ' +\
 9813            '>'
 9814
 9815    def to_dict(self):
 9816        return {
 9817            'meta': self.meta,
 9818            'rate_limit': self.rate_limit,
 9819            'resource': self.resource,
 9820        }
 9821
 9822    @classmethod
 9823    def from_dict(cls, d):
 9824        return cls(
 9825            meta=d.get('meta'),
 9826            rate_limit=d.get('rate_limit'),
 9827            resource=d.get('resource'),
 9828        )
 9829
 9830
 9831class ResourceUpdateResponse:
 9832    '''
 9833     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
 9834     a ResourceUpdateRequest.
 9835    '''
 9836    __slots__ = [
 9837        'meta',
 9838        'rate_limit',
 9839        'resource',
 9840    ]
 9841
 9842    def __init__(
 9843        self,
 9844        meta=None,
 9845        rate_limit=None,
 9846        resource=None,
 9847    ):
 9848        self.meta = meta if meta is not None else None
 9849        '''
 9850         Reserved for future use.
 9851        '''
 9852        self.rate_limit = rate_limit if rate_limit is not None else None
 9853        '''
 9854         Rate limit information.
 9855        '''
 9856        self.resource = resource if resource is not None else None
 9857        '''
 9858         The updated Resource.
 9859        '''
 9860
 9861    def __repr__(self):
 9862        return '<sdm.ResourceUpdateResponse ' + \
 9863            'meta: ' + repr(self.meta) + ' ' +\
 9864            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9865            'resource: ' + repr(self.resource) + ' ' +\
 9866            '>'
 9867
 9868    def to_dict(self):
 9869        return {
 9870            'meta': self.meta,
 9871            'rate_limit': self.rate_limit,
 9872            'resource': self.resource,
 9873        }
 9874
 9875    @classmethod
 9876    def from_dict(cls, d):
 9877        return cls(
 9878            meta=d.get('meta'),
 9879            rate_limit=d.get('rate_limit'),
 9880            resource=d.get('resource'),
 9881        )
 9882
 9883
 9884class Role:
 9885    '''
 9886     A Role has a list of access rules which determine which Resources the members
 9887     of the Role have access to. An Account can be a member of multiple Roles via
 9888     AccountAttachments.
 9889    '''
 9890    __slots__ = [
 9891        'access_rules',
 9892        'composite',
 9893        'id',
 9894        'name',
 9895        'tags',
 9896    ]
 9897
 9898    def __init__(
 9899        self,
 9900        access_rules=None,
 9901        composite=None,
 9902        id=None,
 9903        name=None,
 9904        tags=None,
 9905    ):
 9906        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
 9907        )
 9908        '''
 9909         AccessRules is a list of access rules defining the resources this Role has access to.
 9910        '''
 9911        self.composite = composite if composite is not None else False
 9912        '''
 9913         Composite is true if the Role is a composite role.
 9914         
 9915         Deprecated: composite roles are deprecated, use multi-role via
 9916         AccountAttachments instead.
 9917        '''
 9918        self.id = id if id is not None else ''
 9919        '''
 9920         Unique identifier of the Role.
 9921        '''
 9922        self.name = name if name is not None else ''
 9923        '''
 9924         Unique human-readable name of the Role.
 9925        '''
 9926        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9927        '''
 9928         Tags is a map of key, value pairs.
 9929        '''
 9930
 9931    def __repr__(self):
 9932        return '<sdm.Role ' + \
 9933            'access_rules: ' + repr(self.access_rules) + ' ' +\
 9934            'composite: ' + repr(self.composite) + ' ' +\
 9935            'id: ' + repr(self.id) + ' ' +\
 9936            'name: ' + repr(self.name) + ' ' +\
 9937            'tags: ' + repr(self.tags) + ' ' +\
 9938            '>'
 9939
 9940    def to_dict(self):
 9941        return {
 9942            'access_rules': self.access_rules,
 9943            'composite': self.composite,
 9944            'id': self.id,
 9945            'name': self.name,
 9946            'tags': self.tags,
 9947        }
 9948
 9949    @classmethod
 9950    def from_dict(cls, d):
 9951        return cls(
 9952            access_rules=d.get('access_rules'),
 9953            composite=d.get('composite'),
 9954            id=d.get('id'),
 9955            name=d.get('name'),
 9956            tags=d.get('tags'),
 9957        )
 9958
 9959
 9960class RoleAttachment:
 9961    '''
 9962     A RoleAttachment assigns a role to a composite role.
 9963     
 9964     Deprecated: use multi-role via AccountAttachments instead.
 9965    '''
 9966    __slots__ = [
 9967        'attached_role_id',
 9968        'composite_role_id',
 9969        'id',
 9970    ]
 9971
 9972    def __init__(
 9973        self,
 9974        attached_role_id=None,
 9975        composite_role_id=None,
 9976        id=None,
 9977    ):
 9978        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
 9979        '''
 9980         The id of the attached role of this RoleAttachment.
 9981        '''
 9982        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
 9983        '''
 9984         The id of the composite role of this RoleAttachment.
 9985        '''
 9986        self.id = id if id is not None else ''
 9987        '''
 9988         Unique identifier of the RoleAttachment.
 9989        '''
 9990
 9991    def __repr__(self):
 9992        return '<sdm.RoleAttachment ' + \
 9993            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
 9994            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
 9995            'id: ' + repr(self.id) + ' ' +\
 9996            '>'
 9997
 9998    def to_dict(self):
 9999        return {
10000            'attached_role_id': self.attached_role_id,
10001            'composite_role_id': self.composite_role_id,
10002            'id': self.id,
10003        }
10004
10005    @classmethod
10006    def from_dict(cls, d):
10007        return cls(
10008            attached_role_id=d.get('attached_role_id'),
10009            composite_role_id=d.get('composite_role_id'),
10010            id=d.get('id'),
10011        )
10012
10013
10014class RoleAttachmentCreateResponse:
10015    '''
10016     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
10017     
10018     Deprecated: use multi-role via AccountAttachments instead.
10019    '''
10020    __slots__ = [
10021        'meta',
10022        'rate_limit',
10023        'role_attachment',
10024    ]
10025
10026    def __init__(
10027        self,
10028        meta=None,
10029        rate_limit=None,
10030        role_attachment=None,
10031    ):
10032        self.meta = meta if meta is not None else None
10033        '''
10034         Reserved for future use.
10035        '''
10036        self.rate_limit = rate_limit if rate_limit is not None else None
10037        '''
10038         Rate limit information.
10039        '''
10040        self.role_attachment = role_attachment if role_attachment is not None else None
10041        '''
10042         The created RoleAttachment.
10043        '''
10044
10045    def __repr__(self):
10046        return '<sdm.RoleAttachmentCreateResponse ' + \
10047            'meta: ' + repr(self.meta) + ' ' +\
10048            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10049            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
10050            '>'
10051
10052    def to_dict(self):
10053        return {
10054            'meta': self.meta,
10055            'rate_limit': self.rate_limit,
10056            'role_attachment': self.role_attachment,
10057        }
10058
10059    @classmethod
10060    def from_dict(cls, d):
10061        return cls(
10062            meta=d.get('meta'),
10063            rate_limit=d.get('rate_limit'),
10064            role_attachment=d.get('role_attachment'),
10065        )
10066
10067
10068class RoleAttachmentDeleteResponse:
10069    '''
10070     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
10071     
10072     Deprecated: use multi-role via AccountAttachments instead.
10073    '''
10074    __slots__ = [
10075        'meta',
10076        'rate_limit',
10077    ]
10078
10079    def __init__(
10080        self,
10081        meta=None,
10082        rate_limit=None,
10083    ):
10084        self.meta = meta if meta is not None else None
10085        '''
10086         Reserved for future use.
10087        '''
10088        self.rate_limit = rate_limit if rate_limit is not None else None
10089        '''
10090         Rate limit information.
10091        '''
10092
10093    def __repr__(self):
10094        return '<sdm.RoleAttachmentDeleteResponse ' + \
10095            'meta: ' + repr(self.meta) + ' ' +\
10096            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10097            '>'
10098
10099    def to_dict(self):
10100        return {
10101            'meta': self.meta,
10102            'rate_limit': self.rate_limit,
10103        }
10104
10105    @classmethod
10106    def from_dict(cls, d):
10107        return cls(
10108            meta=d.get('meta'),
10109            rate_limit=d.get('rate_limit'),
10110        )
10111
10112
10113class RoleAttachmentGetResponse:
10114    '''
10115     RoleAttachmentGetResponse returns a requested RoleAttachment.
10116     
10117     Deprecated: use multi-role via AccountAttachments instead.
10118    '''
10119    __slots__ = [
10120        'meta',
10121        'rate_limit',
10122        'role_attachment',
10123    ]
10124
10125    def __init__(
10126        self,
10127        meta=None,
10128        rate_limit=None,
10129        role_attachment=None,
10130    ):
10131        self.meta = meta if meta is not None else None
10132        '''
10133         Reserved for future use.
10134        '''
10135        self.rate_limit = rate_limit if rate_limit is not None else None
10136        '''
10137         Rate limit information.
10138        '''
10139        self.role_attachment = role_attachment if role_attachment is not None else None
10140        '''
10141         The requested RoleAttachment.
10142        '''
10143
10144    def __repr__(self):
10145        return '<sdm.RoleAttachmentGetResponse ' + \
10146            'meta: ' + repr(self.meta) + ' ' +\
10147            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10148            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
10149            '>'
10150
10151    def to_dict(self):
10152        return {
10153            'meta': self.meta,
10154            'rate_limit': self.rate_limit,
10155            'role_attachment': self.role_attachment,
10156        }
10157
10158    @classmethod
10159    def from_dict(cls, d):
10160        return cls(
10161            meta=d.get('meta'),
10162            rate_limit=d.get('rate_limit'),
10163            role_attachment=d.get('role_attachment'),
10164        )
10165
10166
10167class RoleCreateResponse:
10168    '''
10169     RoleCreateResponse reports how the Roles were created in the system. It can
10170     communicate partial successes or failures.
10171    '''
10172    __slots__ = [
10173        'meta',
10174        'rate_limit',
10175        'role',
10176    ]
10177
10178    def __init__(
10179        self,
10180        meta=None,
10181        rate_limit=None,
10182        role=None,
10183    ):
10184        self.meta = meta if meta is not None else None
10185        '''
10186         Reserved for future use.
10187        '''
10188        self.rate_limit = rate_limit if rate_limit is not None else None
10189        '''
10190         Rate limit information.
10191        '''
10192        self.role = role if role is not None else None
10193        '''
10194         The created Role.
10195        '''
10196
10197    def __repr__(self):
10198        return '<sdm.RoleCreateResponse ' + \
10199            'meta: ' + repr(self.meta) + ' ' +\
10200            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10201            'role: ' + repr(self.role) + ' ' +\
10202            '>'
10203
10204    def to_dict(self):
10205        return {
10206            'meta': self.meta,
10207            'rate_limit': self.rate_limit,
10208            'role': self.role,
10209        }
10210
10211    @classmethod
10212    def from_dict(cls, d):
10213        return cls(
10214            meta=d.get('meta'),
10215            rate_limit=d.get('rate_limit'),
10216            role=d.get('role'),
10217        )
10218
10219
10220class RoleDeleteResponse:
10221    '''
10222     RoleDeleteResponse returns information about a Role that was deleted.
10223    '''
10224    __slots__ = [
10225        'meta',
10226        'rate_limit',
10227    ]
10228
10229    def __init__(
10230        self,
10231        meta=None,
10232        rate_limit=None,
10233    ):
10234        self.meta = meta if meta is not None else None
10235        '''
10236         Reserved for future use.
10237        '''
10238        self.rate_limit = rate_limit if rate_limit is not None else None
10239        '''
10240         Rate limit information.
10241        '''
10242
10243    def __repr__(self):
10244        return '<sdm.RoleDeleteResponse ' + \
10245            'meta: ' + repr(self.meta) + ' ' +\
10246            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10247            '>'
10248
10249    def to_dict(self):
10250        return {
10251            'meta': self.meta,
10252            'rate_limit': self.rate_limit,
10253        }
10254
10255    @classmethod
10256    def from_dict(cls, d):
10257        return cls(
10258            meta=d.get('meta'),
10259            rate_limit=d.get('rate_limit'),
10260        )
10261
10262
10263class RoleGetResponse:
10264    '''
10265     RoleGetResponse returns a requested Role.
10266    '''
10267    __slots__ = [
10268        'meta',
10269        'rate_limit',
10270        'role',
10271    ]
10272
10273    def __init__(
10274        self,
10275        meta=None,
10276        rate_limit=None,
10277        role=None,
10278    ):
10279        self.meta = meta if meta is not None else None
10280        '''
10281         Reserved for future use.
10282        '''
10283        self.rate_limit = rate_limit if rate_limit is not None else None
10284        '''
10285         Rate limit information.
10286        '''
10287        self.role = role if role is not None else None
10288        '''
10289         The requested Role.
10290        '''
10291
10292    def __repr__(self):
10293        return '<sdm.RoleGetResponse ' + \
10294            'meta: ' + repr(self.meta) + ' ' +\
10295            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10296            'role: ' + repr(self.role) + ' ' +\
10297            '>'
10298
10299    def to_dict(self):
10300        return {
10301            'meta': self.meta,
10302            'rate_limit': self.rate_limit,
10303            'role': self.role,
10304        }
10305
10306    @classmethod
10307    def from_dict(cls, d):
10308        return cls(
10309            meta=d.get('meta'),
10310            rate_limit=d.get('rate_limit'),
10311            role=d.get('role'),
10312        )
10313
10314
10315class RoleGrant:
10316    '''
10317     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
10318     
10319     Deprecated: use Role access rules instead.
10320    '''
10321    __slots__ = [
10322        'id',
10323        'resource_id',
10324        'role_id',
10325    ]
10326
10327    def __init__(
10328        self,
10329        id=None,
10330        resource_id=None,
10331        role_id=None,
10332    ):
10333        self.id = id if id is not None else ''
10334        '''
10335         Unique identifier of the RoleGrant.
10336        '''
10337        self.resource_id = resource_id if resource_id is not None else ''
10338        '''
10339         The id of the resource of this RoleGrant.
10340        '''
10341        self.role_id = role_id if role_id is not None else ''
10342        '''
10343         The id of the attached role of this RoleGrant.
10344        '''
10345
10346    def __repr__(self):
10347        return '<sdm.RoleGrant ' + \
10348            'id: ' + repr(self.id) + ' ' +\
10349            'resource_id: ' + repr(self.resource_id) + ' ' +\
10350            'role_id: ' + repr(self.role_id) + ' ' +\
10351            '>'
10352
10353    def to_dict(self):
10354        return {
10355            'id': self.id,
10356            'resource_id': self.resource_id,
10357            'role_id': self.role_id,
10358        }
10359
10360    @classmethod
10361    def from_dict(cls, d):
10362        return cls(
10363            id=d.get('id'),
10364            resource_id=d.get('resource_id'),
10365            role_id=d.get('role_id'),
10366        )
10367
10368
10369class RoleGrantCreateResponse:
10370    '''
10371     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
10372     
10373     Deprecated: use Role access rules instead.
10374    '''
10375    __slots__ = [
10376        'meta',
10377        'rate_limit',
10378        'role_grant',
10379    ]
10380
10381    def __init__(
10382        self,
10383        meta=None,
10384        rate_limit=None,
10385        role_grant=None,
10386    ):
10387        self.meta = meta if meta is not None else None
10388        '''
10389         Reserved for future use.
10390        '''
10391        self.rate_limit = rate_limit if rate_limit is not None else None
10392        '''
10393         Rate limit information.
10394        '''
10395        self.role_grant = role_grant if role_grant is not None else None
10396        '''
10397         The created RoleGrant.
10398        '''
10399
10400    def __repr__(self):
10401        return '<sdm.RoleGrantCreateResponse ' + \
10402            'meta: ' + repr(self.meta) + ' ' +\
10403            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10404            'role_grant: ' + repr(self.role_grant) + ' ' +\
10405            '>'
10406
10407    def to_dict(self):
10408        return {
10409            'meta': self.meta,
10410            'rate_limit': self.rate_limit,
10411            'role_grant': self.role_grant,
10412        }
10413
10414    @classmethod
10415    def from_dict(cls, d):
10416        return cls(
10417            meta=d.get('meta'),
10418            rate_limit=d.get('rate_limit'),
10419            role_grant=d.get('role_grant'),
10420        )
10421
10422
10423class RoleGrantDeleteResponse:
10424    '''
10425     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
10426     
10427     Deprecated: use Role access rules instead.
10428    '''
10429    __slots__ = [
10430        'meta',
10431        'rate_limit',
10432    ]
10433
10434    def __init__(
10435        self,
10436        meta=None,
10437        rate_limit=None,
10438    ):
10439        self.meta = meta if meta is not None else None
10440        '''
10441         Reserved for future use.
10442        '''
10443        self.rate_limit = rate_limit if rate_limit is not None else None
10444        '''
10445         Rate limit information.
10446        '''
10447
10448    def __repr__(self):
10449        return '<sdm.RoleGrantDeleteResponse ' + \
10450            'meta: ' + repr(self.meta) + ' ' +\
10451            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10452            '>'
10453
10454    def to_dict(self):
10455        return {
10456            'meta': self.meta,
10457            'rate_limit': self.rate_limit,
10458        }
10459
10460    @classmethod
10461    def from_dict(cls, d):
10462        return cls(
10463            meta=d.get('meta'),
10464            rate_limit=d.get('rate_limit'),
10465        )
10466
10467
10468class RoleGrantGetResponse:
10469    '''
10470     RoleGrantGetResponse returns a requested RoleGrant.
10471     
10472     Deprecated: use Role access rules instead.
10473    '''
10474    __slots__ = [
10475        'meta',
10476        'rate_limit',
10477        'role_grant',
10478    ]
10479
10480    def __init__(
10481        self,
10482        meta=None,
10483        rate_limit=None,
10484        role_grant=None,
10485    ):
10486        self.meta = meta if meta is not None else None
10487        '''
10488         Reserved for future use.
10489        '''
10490        self.rate_limit = rate_limit if rate_limit is not None else None
10491        '''
10492         Rate limit information.
10493        '''
10494        self.role_grant = role_grant if role_grant is not None else None
10495        '''
10496         The requested RoleGrant.
10497        '''
10498
10499    def __repr__(self):
10500        return '<sdm.RoleGrantGetResponse ' + \
10501            'meta: ' + repr(self.meta) + ' ' +\
10502            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10503            'role_grant: ' + repr(self.role_grant) + ' ' +\
10504            '>'
10505
10506    def to_dict(self):
10507        return {
10508            'meta': self.meta,
10509            'rate_limit': self.rate_limit,
10510            'role_grant': self.role_grant,
10511        }
10512
10513    @classmethod
10514    def from_dict(cls, d):
10515        return cls(
10516            meta=d.get('meta'),
10517            rate_limit=d.get('rate_limit'),
10518            role_grant=d.get('role_grant'),
10519        )
10520
10521
10522class RoleUpdateResponse:
10523    '''
10524     RoleUpdateResponse returns the fields of a Role after it has been updated by
10525     a RoleUpdateRequest.
10526    '''
10527    __slots__ = [
10528        'meta',
10529        'rate_limit',
10530        'role',
10531    ]
10532
10533    def __init__(
10534        self,
10535        meta=None,
10536        rate_limit=None,
10537        role=None,
10538    ):
10539        self.meta = meta if meta is not None else None
10540        '''
10541         Reserved for future use.
10542        '''
10543        self.rate_limit = rate_limit if rate_limit is not None else None
10544        '''
10545         Rate limit information.
10546        '''
10547        self.role = role if role is not None else None
10548        '''
10549         The updated Role.
10550        '''
10551
10552    def __repr__(self):
10553        return '<sdm.RoleUpdateResponse ' + \
10554            'meta: ' + repr(self.meta) + ' ' +\
10555            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10556            'role: ' + repr(self.role) + ' ' +\
10557            '>'
10558
10559    def to_dict(self):
10560        return {
10561            'meta': self.meta,
10562            'rate_limit': self.rate_limit,
10563            'role': self.role,
10564        }
10565
10566    @classmethod
10567    def from_dict(cls, d):
10568        return cls(
10569            meta=d.get('meta'),
10570            rate_limit=d.get('rate_limit'),
10571            role=d.get('role'),
10572        )
10573
10574
10575class SQLServer:
10576    '''
10577
10578    '''
10579    __slots__ = [
10580        'database',
10581        'egress_filter',
10582        'healthy',
10583        'hostname',
10584        'id',
10585        'name',
10586        'override_database',
10587        'password',
10588        'port',
10589        'port_override',
10590        'schema',
10591        'secret_store_id',
10592        'tags',
10593        'username',
10594    ]
10595
10596    def __init__(
10597        self,
10598        database=None,
10599        egress_filter=None,
10600        healthy=None,
10601        hostname=None,
10602        id=None,
10603        name=None,
10604        override_database=None,
10605        password=None,
10606        port=None,
10607        port_override=None,
10608        schema=None,
10609        secret_store_id=None,
10610        tags=None,
10611        username=None,
10612    ):
10613        self.database = database if database is not None else ''
10614        '''
10615
10616        '''
10617        self.egress_filter = egress_filter if egress_filter is not None else ''
10618        '''
10619         A filter applied to the routing logic to pin datasource to nodes.
10620        '''
10621        self.healthy = healthy if healthy is not None else False
10622        '''
10623         True if the datasource is reachable and the credentials are valid.
10624        '''
10625        self.hostname = hostname if hostname is not None else ''
10626        '''
10627
10628        '''
10629        self.id = id if id is not None else ''
10630        '''
10631         Unique identifier of the Resource.
10632        '''
10633        self.name = name if name is not None else ''
10634        '''
10635         Unique human-readable name of the Resource.
10636        '''
10637        self.override_database = override_database if override_database is not None else False
10638        '''
10639
10640        '''
10641        self.password = password if password is not None else ''
10642        '''
10643
10644        '''
10645        self.port = port if port is not None else 0
10646        '''
10647
10648        '''
10649        self.port_override = port_override if port_override is not None else 0
10650        '''
10651
10652        '''
10653        self.schema = schema if schema is not None else ''
10654        '''
10655
10656        '''
10657        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10658        '''
10659         ID of the secret store containing credentials for this resource, if any.
10660        '''
10661        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10662        '''
10663         Tags is a map of key, value pairs.
10664        '''
10665        self.username = username if username is not None else ''
10666        '''
10667
10668        '''
10669
10670    def __repr__(self):
10671        return '<sdm.SQLServer ' + \
10672            'database: ' + repr(self.database) + ' ' +\
10673            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10674            'healthy: ' + repr(self.healthy) + ' ' +\
10675            'hostname: ' + repr(self.hostname) + ' ' +\
10676            'id: ' + repr(self.id) + ' ' +\
10677            'name: ' + repr(self.name) + ' ' +\
10678            'override_database: ' + repr(self.override_database) + ' ' +\
10679            'password: ' + repr(self.password) + ' ' +\
10680            'port: ' + repr(self.port) + ' ' +\
10681            'port_override: ' + repr(self.port_override) + ' ' +\
10682            'schema: ' + repr(self.schema) + ' ' +\
10683            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10684            'tags: ' + repr(self.tags) + ' ' +\
10685            'username: ' + repr(self.username) + ' ' +\
10686            '>'
10687
10688    def to_dict(self):
10689        return {
10690            'database': self.database,
10691            'egress_filter': self.egress_filter,
10692            'healthy': self.healthy,
10693            'hostname': self.hostname,
10694            'id': self.id,
10695            'name': self.name,
10696            'override_database': self.override_database,
10697            'password': self.password,
10698            'port': self.port,
10699            'port_override': self.port_override,
10700            'schema': self.schema,
10701            'secret_store_id': self.secret_store_id,
10702            'tags': self.tags,
10703            'username': self.username,
10704        }
10705
10706    @classmethod
10707    def from_dict(cls, d):
10708        return cls(
10709            database=d.get('database'),
10710            egress_filter=d.get('egress_filter'),
10711            healthy=d.get('healthy'),
10712            hostname=d.get('hostname'),
10713            id=d.get('id'),
10714            name=d.get('name'),
10715            override_database=d.get('override_database'),
10716            password=d.get('password'),
10717            port=d.get('port'),
10718            port_override=d.get('port_override'),
10719            schema=d.get('schema'),
10720            secret_store_id=d.get('secret_store_id'),
10721            tags=d.get('tags'),
10722            username=d.get('username'),
10723        )
10724
10725
10726class SSH:
10727    '''
10728
10729    '''
10730    __slots__ = [
10731        'allow_deprecated_key_exchanges',
10732        'egress_filter',
10733        'healthy',
10734        'hostname',
10735        'id',
10736        'name',
10737        'port',
10738        'port_forwarding',
10739        'public_key',
10740        'secret_store_id',
10741        'tags',
10742        'username',
10743    ]
10744
10745    def __init__(
10746        self,
10747        allow_deprecated_key_exchanges=None,
10748        egress_filter=None,
10749        healthy=None,
10750        hostname=None,
10751        id=None,
10752        name=None,
10753        port=None,
10754        port_forwarding=None,
10755        public_key=None,
10756        secret_store_id=None,
10757        tags=None,
10758        username=None,
10759    ):
10760        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10761        '''
10762
10763        '''
10764        self.egress_filter = egress_filter if egress_filter is not None else ''
10765        '''
10766         A filter applied to the routing logic to pin datasource to nodes.
10767        '''
10768        self.healthy = healthy if healthy is not None else False
10769        '''
10770         True if the datasource is reachable and the credentials are valid.
10771        '''
10772        self.hostname = hostname if hostname is not None else ''
10773        '''
10774
10775        '''
10776        self.id = id if id is not None else ''
10777        '''
10778         Unique identifier of the Resource.
10779        '''
10780        self.name = name if name is not None else ''
10781        '''
10782         Unique human-readable name of the Resource.
10783        '''
10784        self.port = port if port is not None else 0
10785        '''
10786
10787        '''
10788        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10789        '''
10790
10791        '''
10792        self.public_key = public_key if public_key is not None else ''
10793        '''
10794
10795        '''
10796        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10797        '''
10798         ID of the secret store containing credentials for this resource, if any.
10799        '''
10800        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10801        '''
10802         Tags is a map of key, value pairs.
10803        '''
10804        self.username = username if username is not None else ''
10805        '''
10806
10807        '''
10808
10809    def __repr__(self):
10810        return '<sdm.SSH ' + \
10811            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10812            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10813            'healthy: ' + repr(self.healthy) + ' ' +\
10814            'hostname: ' + repr(self.hostname) + ' ' +\
10815            'id: ' + repr(self.id) + ' ' +\
10816            'name: ' + repr(self.name) + ' ' +\
10817            'port: ' + repr(self.port) + ' ' +\
10818            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10819            'public_key: ' + repr(self.public_key) + ' ' +\
10820            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10821            'tags: ' + repr(self.tags) + ' ' +\
10822            'username: ' + repr(self.username) + ' ' +\
10823            '>'
10824
10825    def to_dict(self):
10826        return {
10827            'allow_deprecated_key_exchanges':
10828            self.allow_deprecated_key_exchanges,
10829            'egress_filter': self.egress_filter,
10830            'healthy': self.healthy,
10831            'hostname': self.hostname,
10832            'id': self.id,
10833            'name': self.name,
10834            'port': self.port,
10835            'port_forwarding': self.port_forwarding,
10836            'public_key': self.public_key,
10837            'secret_store_id': self.secret_store_id,
10838            'tags': self.tags,
10839            'username': self.username,
10840        }
10841
10842    @classmethod
10843    def from_dict(cls, d):
10844        return cls(
10845            allow_deprecated_key_exchanges=d.get(
10846                'allow_deprecated_key_exchanges'),
10847            egress_filter=d.get('egress_filter'),
10848            healthy=d.get('healthy'),
10849            hostname=d.get('hostname'),
10850            id=d.get('id'),
10851            name=d.get('name'),
10852            port=d.get('port'),
10853            port_forwarding=d.get('port_forwarding'),
10854            public_key=d.get('public_key'),
10855            secret_store_id=d.get('secret_store_id'),
10856            tags=d.get('tags'),
10857            username=d.get('username'),
10858        )
10859
10860
10861class SSHCert:
10862    '''
10863
10864    '''
10865    __slots__ = [
10866        'allow_deprecated_key_exchanges',
10867        'egress_filter',
10868        'healthy',
10869        'hostname',
10870        'id',
10871        'name',
10872        'port',
10873        'port_forwarding',
10874        'secret_store_id',
10875        'tags',
10876        'username',
10877    ]
10878
10879    def __init__(
10880        self,
10881        allow_deprecated_key_exchanges=None,
10882        egress_filter=None,
10883        healthy=None,
10884        hostname=None,
10885        id=None,
10886        name=None,
10887        port=None,
10888        port_forwarding=None,
10889        secret_store_id=None,
10890        tags=None,
10891        username=None,
10892    ):
10893        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10894        '''
10895
10896        '''
10897        self.egress_filter = egress_filter if egress_filter is not None else ''
10898        '''
10899         A filter applied to the routing logic to pin datasource to nodes.
10900        '''
10901        self.healthy = healthy if healthy is not None else False
10902        '''
10903         True if the datasource is reachable and the credentials are valid.
10904        '''
10905        self.hostname = hostname if hostname is not None else ''
10906        '''
10907
10908        '''
10909        self.id = id if id is not None else ''
10910        '''
10911         Unique identifier of the Resource.
10912        '''
10913        self.name = name if name is not None else ''
10914        '''
10915         Unique human-readable name of the Resource.
10916        '''
10917        self.port = port if port is not None else 0
10918        '''
10919
10920        '''
10921        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10922        '''
10923
10924        '''
10925        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10926        '''
10927         ID of the secret store containing credentials for this resource, if any.
10928        '''
10929        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10930        '''
10931         Tags is a map of key, value pairs.
10932        '''
10933        self.username = username if username is not None else ''
10934        '''
10935
10936        '''
10937
10938    def __repr__(self):
10939        return '<sdm.SSHCert ' + \
10940            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10941            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10942            'healthy: ' + repr(self.healthy) + ' ' +\
10943            'hostname: ' + repr(self.hostname) + ' ' +\
10944            'id: ' + repr(self.id) + ' ' +\
10945            'name: ' + repr(self.name) + ' ' +\
10946            'port: ' + repr(self.port) + ' ' +\
10947            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10948            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10949            'tags: ' + repr(self.tags) + ' ' +\
10950            'username: ' + repr(self.username) + ' ' +\
10951            '>'
10952
10953    def to_dict(self):
10954        return {
10955            'allow_deprecated_key_exchanges':
10956            self.allow_deprecated_key_exchanges,
10957            'egress_filter': self.egress_filter,
10958            'healthy': self.healthy,
10959            'hostname': self.hostname,
10960            'id': self.id,
10961            'name': self.name,
10962            'port': self.port,
10963            'port_forwarding': self.port_forwarding,
10964            'secret_store_id': self.secret_store_id,
10965            'tags': self.tags,
10966            'username': self.username,
10967        }
10968
10969    @classmethod
10970    def from_dict(cls, d):
10971        return cls(
10972            allow_deprecated_key_exchanges=d.get(
10973                'allow_deprecated_key_exchanges'),
10974            egress_filter=d.get('egress_filter'),
10975            healthy=d.get('healthy'),
10976            hostname=d.get('hostname'),
10977            id=d.get('id'),
10978            name=d.get('name'),
10979            port=d.get('port'),
10980            port_forwarding=d.get('port_forwarding'),
10981            secret_store_id=d.get('secret_store_id'),
10982            tags=d.get('tags'),
10983            username=d.get('username'),
10984        )
10985
10986
10987class SSHCustomerKey:
10988    '''
10989
10990    '''
10991    __slots__ = [
10992        'allow_deprecated_key_exchanges',
10993        'egress_filter',
10994        'healthy',
10995        'hostname',
10996        'id',
10997        'name',
10998        'port',
10999        'port_forwarding',
11000        'private_key',
11001        'secret_store_id',
11002        'tags',
11003        'username',
11004    ]
11005
11006    def __init__(
11007        self,
11008        allow_deprecated_key_exchanges=None,
11009        egress_filter=None,
11010        healthy=None,
11011        hostname=None,
11012        id=None,
11013        name=None,
11014        port=None,
11015        port_forwarding=None,
11016        private_key=None,
11017        secret_store_id=None,
11018        tags=None,
11019        username=None,
11020    ):
11021        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11022        '''
11023
11024        '''
11025        self.egress_filter = egress_filter if egress_filter is not None else ''
11026        '''
11027         A filter applied to the routing logic to pin datasource to nodes.
11028        '''
11029        self.healthy = healthy if healthy is not None else False
11030        '''
11031         True if the datasource is reachable and the credentials are valid.
11032        '''
11033        self.hostname = hostname if hostname is not None else ''
11034        '''
11035
11036        '''
11037        self.id = id if id is not None else ''
11038        '''
11039         Unique identifier of the Resource.
11040        '''
11041        self.name = name if name is not None else ''
11042        '''
11043         Unique human-readable name of the Resource.
11044        '''
11045        self.port = port if port is not None else 0
11046        '''
11047
11048        '''
11049        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11050        '''
11051
11052        '''
11053        self.private_key = private_key if private_key is not None else ''
11054        '''
11055
11056        '''
11057        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11058        '''
11059         ID of the secret store containing credentials for this resource, if any.
11060        '''
11061        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11062        '''
11063         Tags is a map of key, value pairs.
11064        '''
11065        self.username = username if username is not None else ''
11066        '''
11067
11068        '''
11069
11070    def __repr__(self):
11071        return '<sdm.SSHCustomerKey ' + \
11072            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11073            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11074            'healthy: ' + repr(self.healthy) + ' ' +\
11075            'hostname: ' + repr(self.hostname) + ' ' +\
11076            'id: ' + repr(self.id) + ' ' +\
11077            'name: ' + repr(self.name) + ' ' +\
11078            'port: ' + repr(self.port) + ' ' +\
11079            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11080            'private_key: ' + repr(self.private_key) + ' ' +\
11081            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11082            'tags: ' + repr(self.tags) + ' ' +\
11083            'username: ' + repr(self.username) + ' ' +\
11084            '>'
11085
11086    def to_dict(self):
11087        return {
11088            'allow_deprecated_key_exchanges':
11089            self.allow_deprecated_key_exchanges,
11090            'egress_filter': self.egress_filter,
11091            'healthy': self.healthy,
11092            'hostname': self.hostname,
11093            'id': self.id,
11094            'name': self.name,
11095            'port': self.port,
11096            'port_forwarding': self.port_forwarding,
11097            'private_key': self.private_key,
11098            'secret_store_id': self.secret_store_id,
11099            'tags': self.tags,
11100            'username': self.username,
11101        }
11102
11103    @classmethod
11104    def from_dict(cls, d):
11105        return cls(
11106            allow_deprecated_key_exchanges=d.get(
11107                'allow_deprecated_key_exchanges'),
11108            egress_filter=d.get('egress_filter'),
11109            healthy=d.get('healthy'),
11110            hostname=d.get('hostname'),
11111            id=d.get('id'),
11112            name=d.get('name'),
11113            port=d.get('port'),
11114            port_forwarding=d.get('port_forwarding'),
11115            private_key=d.get('private_key'),
11116            secret_store_id=d.get('secret_store_id'),
11117            tags=d.get('tags'),
11118            username=d.get('username'),
11119        )
11120
11121
11122class SecretStoreCreateResponse:
11123    '''
11124     SecretStoreCreateResponse reports how the SecretStores were created in the system.
11125    '''
11126    __slots__ = [
11127        'meta',
11128        'rate_limit',
11129        'secret_store',
11130    ]
11131
11132    def __init__(
11133        self,
11134        meta=None,
11135        rate_limit=None,
11136        secret_store=None,
11137    ):
11138        self.meta = meta if meta is not None else None
11139        '''
11140         Reserved for future use.
11141        '''
11142        self.rate_limit = rate_limit if rate_limit is not None else None
11143        '''
11144         Rate limit information.
11145        '''
11146        self.secret_store = secret_store if secret_store is not None else None
11147        '''
11148         The created SecretStore.
11149        '''
11150
11151    def __repr__(self):
11152        return '<sdm.SecretStoreCreateResponse ' + \
11153            'meta: ' + repr(self.meta) + ' ' +\
11154            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11155            'secret_store: ' + repr(self.secret_store) + ' ' +\
11156            '>'
11157
11158    def to_dict(self):
11159        return {
11160            'meta': self.meta,
11161            'rate_limit': self.rate_limit,
11162            'secret_store': self.secret_store,
11163        }
11164
11165    @classmethod
11166    def from_dict(cls, d):
11167        return cls(
11168            meta=d.get('meta'),
11169            rate_limit=d.get('rate_limit'),
11170            secret_store=d.get('secret_store'),
11171        )
11172
11173
11174class SecretStoreDeleteResponse:
11175    '''
11176     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11177    '''
11178    __slots__ = [
11179        'meta',
11180        'rate_limit',
11181    ]
11182
11183    def __init__(
11184        self,
11185        meta=None,
11186        rate_limit=None,
11187    ):
11188        self.meta = meta if meta is not None else None
11189        '''
11190         Reserved for future use.
11191        '''
11192        self.rate_limit = rate_limit if rate_limit is not None else None
11193        '''
11194         Rate limit information.
11195        '''
11196
11197    def __repr__(self):
11198        return '<sdm.SecretStoreDeleteResponse ' + \
11199            'meta: ' + repr(self.meta) + ' ' +\
11200            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11201            '>'
11202
11203    def to_dict(self):
11204        return {
11205            'meta': self.meta,
11206            'rate_limit': self.rate_limit,
11207        }
11208
11209    @classmethod
11210    def from_dict(cls, d):
11211        return cls(
11212            meta=d.get('meta'),
11213            rate_limit=d.get('rate_limit'),
11214        )
11215
11216
11217class SecretStoreGetResponse:
11218    '''
11219     SecretStoreGetResponse returns a requested SecretStore.
11220    '''
11221    __slots__ = [
11222        'meta',
11223        'rate_limit',
11224        'secret_store',
11225    ]
11226
11227    def __init__(
11228        self,
11229        meta=None,
11230        rate_limit=None,
11231        secret_store=None,
11232    ):
11233        self.meta = meta if meta is not None else None
11234        '''
11235         Reserved for future use.
11236        '''
11237        self.rate_limit = rate_limit if rate_limit is not None else None
11238        '''
11239         Rate limit information.
11240        '''
11241        self.secret_store = secret_store if secret_store is not None else None
11242        '''
11243         The requested SecretStore.
11244        '''
11245
11246    def __repr__(self):
11247        return '<sdm.SecretStoreGetResponse ' + \
11248            'meta: ' + repr(self.meta) + ' ' +\
11249            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11250            'secret_store: ' + repr(self.secret_store) + ' ' +\
11251            '>'
11252
11253    def to_dict(self):
11254        return {
11255            'meta': self.meta,
11256            'rate_limit': self.rate_limit,
11257            'secret_store': self.secret_store,
11258        }
11259
11260    @classmethod
11261    def from_dict(cls, d):
11262        return cls(
11263            meta=d.get('meta'),
11264            rate_limit=d.get('rate_limit'),
11265            secret_store=d.get('secret_store'),
11266        )
11267
11268
11269class SecretStoreUpdateResponse:
11270    '''
11271     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11272     a SecretStoreUpdateRequest.
11273    '''
11274    __slots__ = [
11275        'meta',
11276        'rate_limit',
11277        'secret_store',
11278    ]
11279
11280    def __init__(
11281        self,
11282        meta=None,
11283        rate_limit=None,
11284        secret_store=None,
11285    ):
11286        self.meta = meta if meta is not None else None
11287        '''
11288         Reserved for future use.
11289        '''
11290        self.rate_limit = rate_limit if rate_limit is not None else None
11291        '''
11292         Rate limit information.
11293        '''
11294        self.secret_store = secret_store if secret_store is not None else None
11295        '''
11296         The updated SecretStore.
11297        '''
11298
11299    def __repr__(self):
11300        return '<sdm.SecretStoreUpdateResponse ' + \
11301            'meta: ' + repr(self.meta) + ' ' +\
11302            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11303            'secret_store: ' + repr(self.secret_store) + ' ' +\
11304            '>'
11305
11306    def to_dict(self):
11307        return {
11308            'meta': self.meta,
11309            'rate_limit': self.rate_limit,
11310            'secret_store': self.secret_store,
11311        }
11312
11313    @classmethod
11314    def from_dict(cls, d):
11315        return cls(
11316            meta=d.get('meta'),
11317            rate_limit=d.get('rate_limit'),
11318            secret_store=d.get('secret_store'),
11319        )
11320
11321
11322class Service:
11323    '''
11324     A Service is a service account that can connect to resources they are granted
11325     directly, or granted via roles. Services are typically automated jobs.
11326    '''
11327    __slots__ = [
11328        'id',
11329        'name',
11330        'suspended',
11331        'tags',
11332    ]
11333
11334    def __init__(
11335        self,
11336        id=None,
11337        name=None,
11338        suspended=None,
11339        tags=None,
11340    ):
11341        self.id = id if id is not None else ''
11342        '''
11343         Unique identifier of the Service.
11344        '''
11345        self.name = name if name is not None else ''
11346        '''
11347         Unique human-readable name of the Service.
11348        '''
11349        self.suspended = suspended if suspended is not None else False
11350        '''
11351         The Service's suspended state.
11352        '''
11353        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11354        '''
11355         Tags is a map of key, value pairs.
11356        '''
11357
11358    def __repr__(self):
11359        return '<sdm.Service ' + \
11360            'id: ' + repr(self.id) + ' ' +\
11361            'name: ' + repr(self.name) + ' ' +\
11362            'suspended: ' + repr(self.suspended) + ' ' +\
11363            'tags: ' + repr(self.tags) + ' ' +\
11364            '>'
11365
11366    def to_dict(self):
11367        return {
11368            'id': self.id,
11369            'name': self.name,
11370            'suspended': self.suspended,
11371            'tags': self.tags,
11372        }
11373
11374    @classmethod
11375    def from_dict(cls, d):
11376        return cls(
11377            id=d.get('id'),
11378            name=d.get('name'),
11379            suspended=d.get('suspended'),
11380            tags=d.get('tags'),
11381        )
11382
11383
11384class SingleStore:
11385    '''
11386
11387    '''
11388    __slots__ = [
11389        'database',
11390        'egress_filter',
11391        'healthy',
11392        'hostname',
11393        'id',
11394        'name',
11395        'password',
11396        'port',
11397        'port_override',
11398        'secret_store_id',
11399        'tags',
11400        'username',
11401    ]
11402
11403    def __init__(
11404        self,
11405        database=None,
11406        egress_filter=None,
11407        healthy=None,
11408        hostname=None,
11409        id=None,
11410        name=None,
11411        password=None,
11412        port=None,
11413        port_override=None,
11414        secret_store_id=None,
11415        tags=None,
11416        username=None,
11417    ):
11418        self.database = database if database is not None else ''
11419        '''
11420
11421        '''
11422        self.egress_filter = egress_filter if egress_filter is not None else ''
11423        '''
11424         A filter applied to the routing logic to pin datasource to nodes.
11425        '''
11426        self.healthy = healthy if healthy is not None else False
11427        '''
11428         True if the datasource is reachable and the credentials are valid.
11429        '''
11430        self.hostname = hostname if hostname is not None else ''
11431        '''
11432
11433        '''
11434        self.id = id if id is not None else ''
11435        '''
11436         Unique identifier of the Resource.
11437        '''
11438        self.name = name if name is not None else ''
11439        '''
11440         Unique human-readable name of the Resource.
11441        '''
11442        self.password = password if password is not None else ''
11443        '''
11444
11445        '''
11446        self.port = port if port is not None else 0
11447        '''
11448
11449        '''
11450        self.port_override = port_override if port_override is not None else 0
11451        '''
11452
11453        '''
11454        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11455        '''
11456         ID of the secret store containing credentials for this resource, if any.
11457        '''
11458        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11459        '''
11460         Tags is a map of key, value pairs.
11461        '''
11462        self.username = username if username is not None else ''
11463        '''
11464
11465        '''
11466
11467    def __repr__(self):
11468        return '<sdm.SingleStore ' + \
11469            'database: ' + repr(self.database) + ' ' +\
11470            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11471            'healthy: ' + repr(self.healthy) + ' ' +\
11472            'hostname: ' + repr(self.hostname) + ' ' +\
11473            'id: ' + repr(self.id) + ' ' +\
11474            'name: ' + repr(self.name) + ' ' +\
11475            'password: ' + repr(self.password) + ' ' +\
11476            'port: ' + repr(self.port) + ' ' +\
11477            'port_override: ' + repr(self.port_override) + ' ' +\
11478            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11479            'tags: ' + repr(self.tags) + ' ' +\
11480            'username: ' + repr(self.username) + ' ' +\
11481            '>'
11482
11483    def to_dict(self):
11484        return {
11485            'database': self.database,
11486            'egress_filter': self.egress_filter,
11487            'healthy': self.healthy,
11488            'hostname': self.hostname,
11489            'id': self.id,
11490            'name': self.name,
11491            'password': self.password,
11492            'port': self.port,
11493            'port_override': self.port_override,
11494            'secret_store_id': self.secret_store_id,
11495            'tags': self.tags,
11496            'username': self.username,
11497        }
11498
11499    @classmethod
11500    def from_dict(cls, d):
11501        return cls(
11502            database=d.get('database'),
11503            egress_filter=d.get('egress_filter'),
11504            healthy=d.get('healthy'),
11505            hostname=d.get('hostname'),
11506            id=d.get('id'),
11507            name=d.get('name'),
11508            password=d.get('password'),
11509            port=d.get('port'),
11510            port_override=d.get('port_override'),
11511            secret_store_id=d.get('secret_store_id'),
11512            tags=d.get('tags'),
11513            username=d.get('username'),
11514        )
11515
11516
11517class Snowflake:
11518    '''
11519
11520    '''
11521    __slots__ = [
11522        'database',
11523        'egress_filter',
11524        'healthy',
11525        'hostname',
11526        'id',
11527        'name',
11528        'password',
11529        'port_override',
11530        'schema',
11531        'secret_store_id',
11532        'tags',
11533        'username',
11534    ]
11535
11536    def __init__(
11537        self,
11538        database=None,
11539        egress_filter=None,
11540        healthy=None,
11541        hostname=None,
11542        id=None,
11543        name=None,
11544        password=None,
11545        port_override=None,
11546        schema=None,
11547        secret_store_id=None,
11548        tags=None,
11549        username=None,
11550    ):
11551        self.database = database if database is not None else ''
11552        '''
11553
11554        '''
11555        self.egress_filter = egress_filter if egress_filter is not None else ''
11556        '''
11557         A filter applied to the routing logic to pin datasource to nodes.
11558        '''
11559        self.healthy = healthy if healthy is not None else False
11560        '''
11561         True if the datasource is reachable and the credentials are valid.
11562        '''
11563        self.hostname = hostname if hostname is not None else ''
11564        '''
11565
11566        '''
11567        self.id = id if id is not None else ''
11568        '''
11569         Unique identifier of the Resource.
11570        '''
11571        self.name = name if name is not None else ''
11572        '''
11573         Unique human-readable name of the Resource.
11574        '''
11575        self.password = password if password is not None else ''
11576        '''
11577
11578        '''
11579        self.port_override = port_override if port_override is not None else 0
11580        '''
11581
11582        '''
11583        self.schema = schema if schema is not None else ''
11584        '''
11585
11586        '''
11587        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11588        '''
11589         ID of the secret store containing credentials for this resource, if any.
11590        '''
11591        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11592        '''
11593         Tags is a map of key, value pairs.
11594        '''
11595        self.username = username if username is not None else ''
11596        '''
11597
11598        '''
11599
11600    def __repr__(self):
11601        return '<sdm.Snowflake ' + \
11602            'database: ' + repr(self.database) + ' ' +\
11603            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11604            'healthy: ' + repr(self.healthy) + ' ' +\
11605            'hostname: ' + repr(self.hostname) + ' ' +\
11606            'id: ' + repr(self.id) + ' ' +\
11607            'name: ' + repr(self.name) + ' ' +\
11608            'password: ' + repr(self.password) + ' ' +\
11609            'port_override: ' + repr(self.port_override) + ' ' +\
11610            'schema: ' + repr(self.schema) + ' ' +\
11611            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11612            'tags: ' + repr(self.tags) + ' ' +\
11613            'username: ' + repr(self.username) + ' ' +\
11614            '>'
11615
11616    def to_dict(self):
11617        return {
11618            'database': self.database,
11619            'egress_filter': self.egress_filter,
11620            'healthy': self.healthy,
11621            'hostname': self.hostname,
11622            'id': self.id,
11623            'name': self.name,
11624            'password': self.password,
11625            'port_override': self.port_override,
11626            'schema': self.schema,
11627            'secret_store_id': self.secret_store_id,
11628            'tags': self.tags,
11629            'username': self.username,
11630        }
11631
11632    @classmethod
11633    def from_dict(cls, d):
11634        return cls(
11635            database=d.get('database'),
11636            egress_filter=d.get('egress_filter'),
11637            healthy=d.get('healthy'),
11638            hostname=d.get('hostname'),
11639            id=d.get('id'),
11640            name=d.get('name'),
11641            password=d.get('password'),
11642            port_override=d.get('port_override'),
11643            schema=d.get('schema'),
11644            secret_store_id=d.get('secret_store_id'),
11645            tags=d.get('tags'),
11646            username=d.get('username'),
11647        )
11648
11649
11650class Sybase:
11651    '''
11652
11653    '''
11654    __slots__ = [
11655        'egress_filter',
11656        'healthy',
11657        'hostname',
11658        'id',
11659        'name',
11660        'password',
11661        'port',
11662        'port_override',
11663        'secret_store_id',
11664        'tags',
11665        'username',
11666    ]
11667
11668    def __init__(
11669        self,
11670        egress_filter=None,
11671        healthy=None,
11672        hostname=None,
11673        id=None,
11674        name=None,
11675        password=None,
11676        port=None,
11677        port_override=None,
11678        secret_store_id=None,
11679        tags=None,
11680        username=None,
11681    ):
11682        self.egress_filter = egress_filter if egress_filter is not None else ''
11683        '''
11684         A filter applied to the routing logic to pin datasource to nodes.
11685        '''
11686        self.healthy = healthy if healthy is not None else False
11687        '''
11688         True if the datasource is reachable and the credentials are valid.
11689        '''
11690        self.hostname = hostname if hostname is not None else ''
11691        '''
11692
11693        '''
11694        self.id = id if id is not None else ''
11695        '''
11696         Unique identifier of the Resource.
11697        '''
11698        self.name = name if name is not None else ''
11699        '''
11700         Unique human-readable name of the Resource.
11701        '''
11702        self.password = password if password is not None else ''
11703        '''
11704
11705        '''
11706        self.port = port if port is not None else 0
11707        '''
11708
11709        '''
11710        self.port_override = port_override if port_override is not None else 0
11711        '''
11712
11713        '''
11714        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11715        '''
11716         ID of the secret store containing credentials for this resource, if any.
11717        '''
11718        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11719        '''
11720         Tags is a map of key, value pairs.
11721        '''
11722        self.username = username if username is not None else ''
11723        '''
11724
11725        '''
11726
11727    def __repr__(self):
11728        return '<sdm.Sybase ' + \
11729            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11730            'healthy: ' + repr(self.healthy) + ' ' +\
11731            'hostname: ' + repr(self.hostname) + ' ' +\
11732            'id: ' + repr(self.id) + ' ' +\
11733            'name: ' + repr(self.name) + ' ' +\
11734            'password: ' + repr(self.password) + ' ' +\
11735            'port: ' + repr(self.port) + ' ' +\
11736            'port_override: ' + repr(self.port_override) + ' ' +\
11737            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11738            'tags: ' + repr(self.tags) + ' ' +\
11739            'username: ' + repr(self.username) + ' ' +\
11740            '>'
11741
11742    def to_dict(self):
11743        return {
11744            'egress_filter': self.egress_filter,
11745            'healthy': self.healthy,
11746            'hostname': self.hostname,
11747            'id': self.id,
11748            'name': self.name,
11749            'password': self.password,
11750            'port': self.port,
11751            'port_override': self.port_override,
11752            'secret_store_id': self.secret_store_id,
11753            'tags': self.tags,
11754            'username': self.username,
11755        }
11756
11757    @classmethod
11758    def from_dict(cls, d):
11759        return cls(
11760            egress_filter=d.get('egress_filter'),
11761            healthy=d.get('healthy'),
11762            hostname=d.get('hostname'),
11763            id=d.get('id'),
11764            name=d.get('name'),
11765            password=d.get('password'),
11766            port=d.get('port'),
11767            port_override=d.get('port_override'),
11768            secret_store_id=d.get('secret_store_id'),
11769            tags=d.get('tags'),
11770            username=d.get('username'),
11771        )
11772
11773
11774class SybaseIQ:
11775    '''
11776
11777    '''
11778    __slots__ = [
11779        'egress_filter',
11780        'healthy',
11781        'hostname',
11782        'id',
11783        'name',
11784        'password',
11785        'port',
11786        'port_override',
11787        'secret_store_id',
11788        'tags',
11789        'username',
11790    ]
11791
11792    def __init__(
11793        self,
11794        egress_filter=None,
11795        healthy=None,
11796        hostname=None,
11797        id=None,
11798        name=None,
11799        password=None,
11800        port=None,
11801        port_override=None,
11802        secret_store_id=None,
11803        tags=None,
11804        username=None,
11805    ):
11806        self.egress_filter = egress_filter if egress_filter is not None else ''
11807        '''
11808         A filter applied to the routing logic to pin datasource to nodes.
11809        '''
11810        self.healthy = healthy if healthy is not None else False
11811        '''
11812         True if the datasource is reachable and the credentials are valid.
11813        '''
11814        self.hostname = hostname if hostname is not None else ''
11815        '''
11816
11817        '''
11818        self.id = id if id is not None else ''
11819        '''
11820         Unique identifier of the Resource.
11821        '''
11822        self.name = name if name is not None else ''
11823        '''
11824         Unique human-readable name of the Resource.
11825        '''
11826        self.password = password if password is not None else ''
11827        '''
11828
11829        '''
11830        self.port = port if port is not None else 0
11831        '''
11832
11833        '''
11834        self.port_override = port_override if port_override is not None else 0
11835        '''
11836
11837        '''
11838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11839        '''
11840         ID of the secret store containing credentials for this resource, if any.
11841        '''
11842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11843        '''
11844         Tags is a map of key, value pairs.
11845        '''
11846        self.username = username if username is not None else ''
11847        '''
11848
11849        '''
11850
11851    def __repr__(self):
11852        return '<sdm.SybaseIQ ' + \
11853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11854            'healthy: ' + repr(self.healthy) + ' ' +\
11855            'hostname: ' + repr(self.hostname) + ' ' +\
11856            'id: ' + repr(self.id) + ' ' +\
11857            'name: ' + repr(self.name) + ' ' +\
11858            'password: ' + repr(self.password) + ' ' +\
11859            'port: ' + repr(self.port) + ' ' +\
11860            'port_override: ' + repr(self.port_override) + ' ' +\
11861            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11862            'tags: ' + repr(self.tags) + ' ' +\
11863            'username: ' + repr(self.username) + ' ' +\
11864            '>'
11865
11866    def to_dict(self):
11867        return {
11868            'egress_filter': self.egress_filter,
11869            'healthy': self.healthy,
11870            'hostname': self.hostname,
11871            'id': self.id,
11872            'name': self.name,
11873            'password': self.password,
11874            'port': self.port,
11875            'port_override': self.port_override,
11876            'secret_store_id': self.secret_store_id,
11877            'tags': self.tags,
11878            'username': self.username,
11879        }
11880
11881    @classmethod
11882    def from_dict(cls, d):
11883        return cls(
11884            egress_filter=d.get('egress_filter'),
11885            healthy=d.get('healthy'),
11886            hostname=d.get('hostname'),
11887            id=d.get('id'),
11888            name=d.get('name'),
11889            password=d.get('password'),
11890            port=d.get('port'),
11891            port_override=d.get('port_override'),
11892            secret_store_id=d.get('secret_store_id'),
11893            tags=d.get('tags'),
11894            username=d.get('username'),
11895        )
11896
11897
11898class Tag:
11899    '''
11900
11901    '''
11902    __slots__ = [
11903        'name',
11904        'value',
11905    ]
11906
11907    def __init__(
11908        self,
11909        name=None,
11910        value=None,
11911    ):
11912        self.name = name if name is not None else ''
11913        '''
11914
11915        '''
11916        self.value = value if value is not None else ''
11917        '''
11918
11919        '''
11920
11921    def __repr__(self):
11922        return '<sdm.Tag ' + \
11923            'name: ' + repr(self.name) + ' ' +\
11924            'value: ' + repr(self.value) + ' ' +\
11925            '>'
11926
11927    def to_dict(self):
11928        return {
11929            'name': self.name,
11930            'value': self.value,
11931        }
11932
11933    @classmethod
11934    def from_dict(cls, d):
11935        return cls(
11936            name=d.get('name'),
11937            value=d.get('value'),
11938        )
11939
11940
11941class Teradata:
11942    '''
11943
11944    '''
11945    __slots__ = [
11946        'egress_filter',
11947        'healthy',
11948        'hostname',
11949        'id',
11950        'name',
11951        'password',
11952        'port',
11953        'port_override',
11954        'secret_store_id',
11955        'tags',
11956        'username',
11957    ]
11958
11959    def __init__(
11960        self,
11961        egress_filter=None,
11962        healthy=None,
11963        hostname=None,
11964        id=None,
11965        name=None,
11966        password=None,
11967        port=None,
11968        port_override=None,
11969        secret_store_id=None,
11970        tags=None,
11971        username=None,
11972    ):
11973        self.egress_filter = egress_filter if egress_filter is not None else ''
11974        '''
11975         A filter applied to the routing logic to pin datasource to nodes.
11976        '''
11977        self.healthy = healthy if healthy is not None else False
11978        '''
11979         True if the datasource is reachable and the credentials are valid.
11980        '''
11981        self.hostname = hostname if hostname is not None else ''
11982        '''
11983
11984        '''
11985        self.id = id if id is not None else ''
11986        '''
11987         Unique identifier of the Resource.
11988        '''
11989        self.name = name if name is not None else ''
11990        '''
11991         Unique human-readable name of the Resource.
11992        '''
11993        self.password = password if password is not None else ''
11994        '''
11995
11996        '''
11997        self.port = port if port is not None else 0
11998        '''
11999
12000        '''
12001        self.port_override = port_override if port_override is not None else 0
12002        '''
12003
12004        '''
12005        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12006        '''
12007         ID of the secret store containing credentials for this resource, if any.
12008        '''
12009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12010        '''
12011         Tags is a map of key, value pairs.
12012        '''
12013        self.username = username if username is not None else ''
12014        '''
12015
12016        '''
12017
12018    def __repr__(self):
12019        return '<sdm.Teradata ' + \
12020            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12021            'healthy: ' + repr(self.healthy) + ' ' +\
12022            'hostname: ' + repr(self.hostname) + ' ' +\
12023            'id: ' + repr(self.id) + ' ' +\
12024            'name: ' + repr(self.name) + ' ' +\
12025            'password: ' + repr(self.password) + ' ' +\
12026            'port: ' + repr(self.port) + ' ' +\
12027            'port_override: ' + repr(self.port_override) + ' ' +\
12028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12029            'tags: ' + repr(self.tags) + ' ' +\
12030            'username: ' + repr(self.username) + ' ' +\
12031            '>'
12032
12033    def to_dict(self):
12034        return {
12035            'egress_filter': self.egress_filter,
12036            'healthy': self.healthy,
12037            'hostname': self.hostname,
12038            'id': self.id,
12039            'name': self.name,
12040            'password': self.password,
12041            'port': self.port,
12042            'port_override': self.port_override,
12043            'secret_store_id': self.secret_store_id,
12044            'tags': self.tags,
12045            'username': self.username,
12046        }
12047
12048    @classmethod
12049    def from_dict(cls, d):
12050        return cls(
12051            egress_filter=d.get('egress_filter'),
12052            healthy=d.get('healthy'),
12053            hostname=d.get('hostname'),
12054            id=d.get('id'),
12055            name=d.get('name'),
12056            password=d.get('password'),
12057            port=d.get('port'),
12058            port_override=d.get('port_override'),
12059            secret_store_id=d.get('secret_store_id'),
12060            tags=d.get('tags'),
12061            username=d.get('username'),
12062        )
12063
12064
12065class UpdateResponseMetadata:
12066    '''
12067     UpdateResponseMetadata is reserved for future use.
12068    '''
12069    __slots__ = []
12070
12071    def __init__(self, ):
12072        pass
12073
12074    def __repr__(self):
12075        return '<sdm.UpdateResponseMetadata ' + \
12076            '>'
12077
12078    def to_dict(self):
12079        return {}
12080
12081    @classmethod
12082    def from_dict(cls, d):
12083        return cls()
12084
12085
12086class User:
12087    '''
12088     A User can connect to resources they are granted directly, or granted
12089     via roles.
12090    '''
12091    __slots__ = [
12092        'email',
12093        'first_name',
12094        'id',
12095        'last_name',
12096        'suspended',
12097        'tags',
12098    ]
12099
12100    def __init__(
12101        self,
12102        email=None,
12103        first_name=None,
12104        id=None,
12105        last_name=None,
12106        suspended=None,
12107        tags=None,
12108    ):
12109        self.email = email if email is not None else ''
12110        '''
12111         The User's email address. Must be unique.
12112        '''
12113        self.first_name = first_name if first_name is not None else ''
12114        '''
12115         The User's first name.
12116        '''
12117        self.id = id if id is not None else ''
12118        '''
12119         Unique identifier of the User.
12120        '''
12121        self.last_name = last_name if last_name is not None else ''
12122        '''
12123         The User's last name.
12124        '''
12125        self.suspended = suspended if suspended is not None else False
12126        '''
12127         The User's suspended state.
12128        '''
12129        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12130        '''
12131         Tags is a map of key, value pairs.
12132        '''
12133
12134    def __repr__(self):
12135        return '<sdm.User ' + \
12136            'email: ' + repr(self.email) + ' ' +\
12137            'first_name: ' + repr(self.first_name) + ' ' +\
12138            'id: ' + repr(self.id) + ' ' +\
12139            'last_name: ' + repr(self.last_name) + ' ' +\
12140            'suspended: ' + repr(self.suspended) + ' ' +\
12141            'tags: ' + repr(self.tags) + ' ' +\
12142            '>'
12143
12144    def to_dict(self):
12145        return {
12146            'email': self.email,
12147            'first_name': self.first_name,
12148            'id': self.id,
12149            'last_name': self.last_name,
12150            'suspended': self.suspended,
12151            'tags': self.tags,
12152        }
12153
12154    @classmethod
12155    def from_dict(cls, d):
12156        return cls(
12157            email=d.get('email'),
12158            first_name=d.get('first_name'),
12159            id=d.get('id'),
12160            last_name=d.get('last_name'),
12161            suspended=d.get('suspended'),
12162            tags=d.get('tags'),
12163        )
12164
12165
12166class VaultAppRoleStore:
12167    '''
12168
12169    '''
12170    __slots__ = [
12171        'id',
12172        'name',
12173        'namespace',
12174        'server_address',
12175        'tags',
12176    ]
12177
12178    def __init__(
12179        self,
12180        id=None,
12181        name=None,
12182        namespace=None,
12183        server_address=None,
12184        tags=None,
12185    ):
12186        self.id = id if id is not None else ''
12187        '''
12188         Unique identifier of the SecretStore.
12189        '''
12190        self.name = name if name is not None else ''
12191        '''
12192         Unique human-readable name of the SecretStore.
12193        '''
12194        self.namespace = namespace if namespace is not None else ''
12195        '''
12196
12197        '''
12198        self.server_address = server_address if server_address is not None else ''
12199        '''
12200
12201        '''
12202        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12203        '''
12204         Tags is a map of key, value pairs.
12205        '''
12206
12207    def __repr__(self):
12208        return '<sdm.VaultAppRoleStore ' + \
12209            'id: ' + repr(self.id) + ' ' +\
12210            'name: ' + repr(self.name) + ' ' +\
12211            'namespace: ' + repr(self.namespace) + ' ' +\
12212            'server_address: ' + repr(self.server_address) + ' ' +\
12213            'tags: ' + repr(self.tags) + ' ' +\
12214            '>'
12215
12216    def to_dict(self):
12217        return {
12218            'id': self.id,
12219            'name': self.name,
12220            'namespace': self.namespace,
12221            'server_address': self.server_address,
12222            'tags': self.tags,
12223        }
12224
12225    @classmethod
12226    def from_dict(cls, d):
12227        return cls(
12228            id=d.get('id'),
12229            name=d.get('name'),
12230            namespace=d.get('namespace'),
12231            server_address=d.get('server_address'),
12232            tags=d.get('tags'),
12233        )
12234
12235
12236class VaultTLSStore:
12237    '''
12238
12239    '''
12240    __slots__ = [
12241        'ca_cert_path',
12242        'client_cert_path',
12243        'client_key_path',
12244        'id',
12245        'name',
12246        'namespace',
12247        'server_address',
12248        'tags',
12249    ]
12250
12251    def __init__(
12252        self,
12253        ca_cert_path=None,
12254        client_cert_path=None,
12255        client_key_path=None,
12256        id=None,
12257        name=None,
12258        namespace=None,
12259        server_address=None,
12260        tags=None,
12261    ):
12262        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12263        '''
12264
12265        '''
12266        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12267        '''
12268
12269        '''
12270        self.client_key_path = client_key_path if client_key_path is not None else ''
12271        '''
12272
12273        '''
12274        self.id = id if id is not None else ''
12275        '''
12276         Unique identifier of the SecretStore.
12277        '''
12278        self.name = name if name is not None else ''
12279        '''
12280         Unique human-readable name of the SecretStore.
12281        '''
12282        self.namespace = namespace if namespace is not None else ''
12283        '''
12284
12285        '''
12286        self.server_address = server_address if server_address is not None else ''
12287        '''
12288
12289        '''
12290        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12291        '''
12292         Tags is a map of key, value pairs.
12293        '''
12294
12295    def __repr__(self):
12296        return '<sdm.VaultTLSStore ' + \
12297            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12298            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12299            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12300            'id: ' + repr(self.id) + ' ' +\
12301            'name: ' + repr(self.name) + ' ' +\
12302            'namespace: ' + repr(self.namespace) + ' ' +\
12303            'server_address: ' + repr(self.server_address) + ' ' +\
12304            'tags: ' + repr(self.tags) + ' ' +\
12305            '>'
12306
12307    def to_dict(self):
12308        return {
12309            'ca_cert_path': self.ca_cert_path,
12310            'client_cert_path': self.client_cert_path,
12311            'client_key_path': self.client_key_path,
12312            'id': self.id,
12313            'name': self.name,
12314            'namespace': self.namespace,
12315            'server_address': self.server_address,
12316            'tags': self.tags,
12317        }
12318
12319    @classmethod
12320    def from_dict(cls, d):
12321        return cls(
12322            ca_cert_path=d.get('ca_cert_path'),
12323            client_cert_path=d.get('client_cert_path'),
12324            client_key_path=d.get('client_key_path'),
12325            id=d.get('id'),
12326            name=d.get('name'),
12327            namespace=d.get('namespace'),
12328            server_address=d.get('server_address'),
12329            tags=d.get('tags'),
12330        )
12331
12332
12333class VaultTokenStore:
12334    '''
12335
12336    '''
12337    __slots__ = [
12338        'id',
12339        'name',
12340        'namespace',
12341        'server_address',
12342        'tags',
12343    ]
12344
12345    def __init__(
12346        self,
12347        id=None,
12348        name=None,
12349        namespace=None,
12350        server_address=None,
12351        tags=None,
12352    ):
12353        self.id = id if id is not None else ''
12354        '''
12355         Unique identifier of the SecretStore.
12356        '''
12357        self.name = name if name is not None else ''
12358        '''
12359         Unique human-readable name of the SecretStore.
12360        '''
12361        self.namespace = namespace if namespace is not None else ''
12362        '''
12363
12364        '''
12365        self.server_address = server_address if server_address is not None else ''
12366        '''
12367
12368        '''
12369        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12370        '''
12371         Tags is a map of key, value pairs.
12372        '''
12373
12374    def __repr__(self):
12375        return '<sdm.VaultTokenStore ' + \
12376            'id: ' + repr(self.id) + ' ' +\
12377            'name: ' + repr(self.name) + ' ' +\
12378            'namespace: ' + repr(self.namespace) + ' ' +\
12379            'server_address: ' + repr(self.server_address) + ' ' +\
12380            'tags: ' + repr(self.tags) + ' ' +\
12381            '>'
12382
12383    def to_dict(self):
12384        return {
12385            'id': self.id,
12386            'name': self.name,
12387            'namespace': self.namespace,
12388            'server_address': self.server_address,
12389            'tags': self.tags,
12390        }
12391
12392    @classmethod
12393    def from_dict(cls, d):
12394        return cls(
12395            id=d.get('id'),
12396            name=d.get('name'),
12397            namespace=d.get('namespace'),
12398            server_address=d.get('server_address'),
12399            tags=d.get('tags'),
12400        )
12401
12402
12403def _porcelain_zero_value_tags():
12404    return {}
12405
12406
12407def _porcelain_zero_value_access_rules():
12408    return []
#   class AKS:
View Source
 21class AKS:
 22    '''
 23
 24    '''
 25    __slots__ = [
 26        'certificate_authority',
 27        'client_certificate',
 28        'client_key',
 29        'egress_filter',
 30        'healthcheck_namespace',
 31        'healthy',
 32        'hostname',
 33        'id',
 34        'name',
 35        'port',
 36        'secret_store_id',
 37        'tags',
 38    ]
 39
 40    def __init__(
 41        self,
 42        certificate_authority=None,
 43        client_certificate=None,
 44        client_key=None,
 45        egress_filter=None,
 46        healthcheck_namespace=None,
 47        healthy=None,
 48        hostname=None,
 49        id=None,
 50        name=None,
 51        port=None,
 52        secret_store_id=None,
 53        tags=None,
 54    ):
 55        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 56        '''
 57
 58        '''
 59        self.client_certificate = client_certificate if client_certificate is not None else ''
 60        '''
 61
 62        '''
 63        self.client_key = client_key if client_key is not None else ''
 64        '''
 65
 66        '''
 67        self.egress_filter = egress_filter if egress_filter is not None else ''
 68        '''
 69         A filter applied to the routing logic to pin datasource to nodes.
 70        '''
 71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 72        '''
 73         The path used to check the health of your connection.  Defaults to `default`.
 74        '''
 75        self.healthy = healthy if healthy is not None else False
 76        '''
 77         True if the datasource is reachable and the credentials are valid.
 78        '''
 79        self.hostname = hostname if hostname is not None else ''
 80        '''
 81
 82        '''
 83        self.id = id if id is not None else ''
 84        '''
 85         Unique identifier of the Resource.
 86        '''
 87        self.name = name if name is not None else ''
 88        '''
 89         Unique human-readable name of the Resource.
 90        '''
 91        self.port = port if port is not None else 0
 92        '''
 93
 94        '''
 95        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 96        '''
 97         ID of the secret store containing credentials for this resource, if any.
 98        '''
 99        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
100        '''
101         Tags is a map of key, value pairs.
102        '''
103
104    def __repr__(self):
105        return '<sdm.AKS ' + \
106            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
107            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
108            'client_key: ' + repr(self.client_key) + ' ' +\
109            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
110            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
111            'healthy: ' + repr(self.healthy) + ' ' +\
112            'hostname: ' + repr(self.hostname) + ' ' +\
113            'id: ' + repr(self.id) + ' ' +\
114            'name: ' + repr(self.name) + ' ' +\
115            'port: ' + repr(self.port) + ' ' +\
116            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
117            'tags: ' + repr(self.tags) + ' ' +\
118            '>'
119
120    def to_dict(self):
121        return {
122            'certificate_authority': self.certificate_authority,
123            'client_certificate': self.client_certificate,
124            'client_key': self.client_key,
125            'egress_filter': self.egress_filter,
126            'healthcheck_namespace': self.healthcheck_namespace,
127            'healthy': self.healthy,
128            'hostname': self.hostname,
129            'id': self.id,
130            'name': self.name,
131            'port': self.port,
132            'secret_store_id': self.secret_store_id,
133            'tags': self.tags,
134        }
135
136    @classmethod
137    def from_dict(cls, d):
138        return cls(
139            certificate_authority=d.get('certificate_authority'),
140            client_certificate=d.get('client_certificate'),
141            client_key=d.get('client_key'),
142            egress_filter=d.get('egress_filter'),
143            healthcheck_namespace=d.get('healthcheck_namespace'),
144            healthy=d.get('healthy'),
145            hostname=d.get('hostname'),
146            id=d.get('id'),
147            name=d.get('name'),
148            port=d.get('port'),
149            secret_store_id=d.get('secret_store_id'),
150            tags=d.get('tags'),
151        )
#   AKS( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
 40    def __init__(
 41        self,
 42        certificate_authority=None,
 43        client_certificate=None,
 44        client_key=None,
 45        egress_filter=None,
 46        healthcheck_namespace=None,
 47        healthy=None,
 48        hostname=None,
 49        id=None,
 50        name=None,
 51        port=None,
 52        secret_store_id=None,
 53        tags=None,
 54    ):
 55        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 56        '''
 57
 58        '''
 59        self.client_certificate = client_certificate if client_certificate is not None else ''
 60        '''
 61
 62        '''
 63        self.client_key = client_key if client_key is not None else ''
 64        '''
 65
 66        '''
 67        self.egress_filter = egress_filter if egress_filter is not None else ''
 68        '''
 69         A filter applied to the routing logic to pin datasource to nodes.
 70        '''
 71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 72        '''
 73         The path used to check the health of your connection.  Defaults to `default`.
 74        '''
 75        self.healthy = healthy if healthy is not None else False
 76        '''
 77         True if the datasource is reachable and the credentials are valid.
 78        '''
 79        self.hostname = hostname if hostname is not None else ''
 80        '''
 81
 82        '''
 83        self.id = id if id is not None else ''
 84        '''
 85         Unique identifier of the Resource.
 86        '''
 87        self.name = name if name is not None else ''
 88        '''
 89         Unique human-readable name of the Resource.
 90        '''
 91        self.port = port if port is not None else 0
 92        '''
 93
 94        '''
 95        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 96        '''
 97         ID of the secret store containing credentials for this resource, if any.
 98        '''
 99        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
100        '''
101         Tags is a map of key, value pairs.
102        '''
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
120    def to_dict(self):
121        return {
122            'certificate_authority': self.certificate_authority,
123            'client_certificate': self.client_certificate,
124            'client_key': self.client_key,
125            'egress_filter': self.egress_filter,
126            'healthcheck_namespace': self.healthcheck_namespace,
127            'healthy': self.healthy,
128            'hostname': self.hostname,
129            'id': self.id,
130            'name': self.name,
131            'port': self.port,
132            'secret_store_id': self.secret_store_id,
133            'tags': self.tags,
134        }
#  
@classmethod
def from_dict(cls, d):
View Source
136    @classmethod
137    def from_dict(cls, d):
138        return cls(
139            certificate_authority=d.get('certificate_authority'),
140            client_certificate=d.get('client_certificate'),
141            client_key=d.get('client_key'),
142            egress_filter=d.get('egress_filter'),
143            healthcheck_namespace=d.get('healthcheck_namespace'),
144            healthy=d.get('healthy'),
145            hostname=d.get('hostname'),
146            id=d.get('id'),
147            name=d.get('name'),
148            port=d.get('port'),
149            secret_store_id=d.get('secret_store_id'),
150            tags=d.get('tags'),
151        )
#   class AKSBasicAuth:
View Source
154class AKSBasicAuth:
155    '''
156
157    '''
158    __slots__ = [
159        'egress_filter',
160        'healthcheck_namespace',
161        'healthy',
162        'hostname',
163        'id',
164        'name',
165        'password',
166        'port',
167        'secret_store_id',
168        'tags',
169        'username',
170    ]
171
172    def __init__(
173        self,
174        egress_filter=None,
175        healthcheck_namespace=None,
176        healthy=None,
177        hostname=None,
178        id=None,
179        name=None,
180        password=None,
181        port=None,
182        secret_store_id=None,
183        tags=None,
184        username=None,
185    ):
186        self.egress_filter = egress_filter if egress_filter is not None else ''
187        '''
188         A filter applied to the routing logic to pin datasource to nodes.
189        '''
190        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
191        '''
192         The path used to check the health of your connection.  Defaults to `default`.
193        '''
194        self.healthy = healthy if healthy is not None else False
195        '''
196         True if the datasource is reachable and the credentials are valid.
197        '''
198        self.hostname = hostname if hostname is not None else ''
199        '''
200
201        '''
202        self.id = id if id is not None else ''
203        '''
204         Unique identifier of the Resource.
205        '''
206        self.name = name if name is not None else ''
207        '''
208         Unique human-readable name of the Resource.
209        '''
210        self.password = password if password is not None else ''
211        '''
212
213        '''
214        self.port = port if port is not None else 0
215        '''
216
217        '''
218        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
219        '''
220         ID of the secret store containing credentials for this resource, if any.
221        '''
222        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
223        '''
224         Tags is a map of key, value pairs.
225        '''
226        self.username = username if username is not None else ''
227        '''
228
229        '''
230
231    def __repr__(self):
232        return '<sdm.AKSBasicAuth ' + \
233            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
234            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
235            'healthy: ' + repr(self.healthy) + ' ' +\
236            'hostname: ' + repr(self.hostname) + ' ' +\
237            'id: ' + repr(self.id) + ' ' +\
238            'name: ' + repr(self.name) + ' ' +\
239            'password: ' + repr(self.password) + ' ' +\
240            'port: ' + repr(self.port) + ' ' +\
241            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
242            'tags: ' + repr(self.tags) + ' ' +\
243            'username: ' + repr(self.username) + ' ' +\
244            '>'
245
246    def to_dict(self):
247        return {
248            'egress_filter': self.egress_filter,
249            'healthcheck_namespace': self.healthcheck_namespace,
250            'healthy': self.healthy,
251            'hostname': self.hostname,
252            'id': self.id,
253            'name': self.name,
254            'password': self.password,
255            'port': self.port,
256            'secret_store_id': self.secret_store_id,
257            'tags': self.tags,
258            'username': self.username,
259        }
260
261    @classmethod
262    def from_dict(cls, d):
263        return cls(
264            egress_filter=d.get('egress_filter'),
265            healthcheck_namespace=d.get('healthcheck_namespace'),
266            healthy=d.get('healthy'),
267            hostname=d.get('hostname'),
268            id=d.get('id'),
269            name=d.get('name'),
270            password=d.get('password'),
271            port=d.get('port'),
272            secret_store_id=d.get('secret_store_id'),
273            tags=d.get('tags'),
274            username=d.get('username'),
275        )
#   AKSBasicAuth( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, secret_store_id=None, tags=None, username=None )
View Source
172    def __init__(
173        self,
174        egress_filter=None,
175        healthcheck_namespace=None,
176        healthy=None,
177        hostname=None,
178        id=None,
179        name=None,
180        password=None,
181        port=None,
182        secret_store_id=None,
183        tags=None,
184        username=None,
185    ):
186        self.egress_filter = egress_filter if egress_filter is not None else ''
187        '''
188         A filter applied to the routing logic to pin datasource to nodes.
189        '''
190        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
191        '''
192         The path used to check the health of your connection.  Defaults to `default`.
193        '''
194        self.healthy = healthy if healthy is not None else False
195        '''
196         True if the datasource is reachable and the credentials are valid.
197        '''
198        self.hostname = hostname if hostname is not None else ''
199        '''
200
201        '''
202        self.id = id if id is not None else ''
203        '''
204         Unique identifier of the Resource.
205        '''
206        self.name = name if name is not None else ''
207        '''
208         Unique human-readable name of the Resource.
209        '''
210        self.password = password if password is not None else ''
211        '''
212
213        '''
214        self.port = port if port is not None else 0
215        '''
216
217        '''
218        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
219        '''
220         ID of the secret store containing credentials for this resource, if any.
221        '''
222        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
223        '''
224         Tags is a map of key, value pairs.
225        '''
226        self.username = username if username is not None else ''
227        '''
228
229        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
246    def to_dict(self):
247        return {
248            'egress_filter': self.egress_filter,
249            'healthcheck_namespace': self.healthcheck_namespace,
250            'healthy': self.healthy,
251            'hostname': self.hostname,
252            'id': self.id,
253            'name': self.name,
254            'password': self.password,
255            'port': self.port,
256            'secret_store_id': self.secret_store_id,
257            'tags': self.tags,
258            'username': self.username,
259        }
#  
@classmethod
def from_dict(cls, d):
View Source
261    @classmethod
262    def from_dict(cls, d):
263        return cls(
264            egress_filter=d.get('egress_filter'),
265            healthcheck_namespace=d.get('healthcheck_namespace'),
266            healthy=d.get('healthy'),
267            hostname=d.get('hostname'),
268            id=d.get('id'),
269            name=d.get('name'),
270            password=d.get('password'),
271            port=d.get('port'),
272            secret_store_id=d.get('secret_store_id'),
273            tags=d.get('tags'),
274            username=d.get('username'),
275        )
#   class AKSServiceAccount:
View Source
278class AKSServiceAccount:
279    '''
280
281    '''
282    __slots__ = [
283        'egress_filter',
284        'healthcheck_namespace',
285        'healthy',
286        'hostname',
287        'id',
288        'name',
289        'port',
290        'secret_store_id',
291        'tags',
292        'token',
293    ]
294
295    def __init__(
296        self,
297        egress_filter=None,
298        healthcheck_namespace=None,
299        healthy=None,
300        hostname=None,
301        id=None,
302        name=None,
303        port=None,
304        secret_store_id=None,
305        tags=None,
306        token=None,
307    ):
308        self.egress_filter = egress_filter if egress_filter is not None else ''
309        '''
310         A filter applied to the routing logic to pin datasource to nodes.
311        '''
312        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
313        '''
314         The path used to check the health of your connection.  Defaults to `default`.
315        '''
316        self.healthy = healthy if healthy is not None else False
317        '''
318         True if the datasource is reachable and the credentials are valid.
319        '''
320        self.hostname = hostname if hostname is not None else ''
321        '''
322
323        '''
324        self.id = id if id is not None else ''
325        '''
326         Unique identifier of the Resource.
327        '''
328        self.name = name if name is not None else ''
329        '''
330         Unique human-readable name of the Resource.
331        '''
332        self.port = port if port is not None else 0
333        '''
334
335        '''
336        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
337        '''
338         ID of the secret store containing credentials for this resource, if any.
339        '''
340        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
341        '''
342         Tags is a map of key, value pairs.
343        '''
344        self.token = token if token is not None else ''
345        '''
346
347        '''
348
349    def __repr__(self):
350        return '<sdm.AKSServiceAccount ' + \
351            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
352            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
353            'healthy: ' + repr(self.healthy) + ' ' +\
354            'hostname: ' + repr(self.hostname) + ' ' +\
355            'id: ' + repr(self.id) + ' ' +\
356            'name: ' + repr(self.name) + ' ' +\
357            'port: ' + repr(self.port) + ' ' +\
358            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
359            'tags: ' + repr(self.tags) + ' ' +\
360            'token: ' + repr(self.token) + ' ' +\
361            '>'
362
363    def to_dict(self):
364        return {
365            'egress_filter': self.egress_filter,
366            'healthcheck_namespace': self.healthcheck_namespace,
367            'healthy': self.healthy,
368            'hostname': self.hostname,
369            'id': self.id,
370            'name': self.name,
371            'port': self.port,
372            'secret_store_id': self.secret_store_id,
373            'tags': self.tags,
374            'token': self.token,
375        }
376
377    @classmethod
378    def from_dict(cls, d):
379        return cls(
380            egress_filter=d.get('egress_filter'),
381            healthcheck_namespace=d.get('healthcheck_namespace'),
382            healthy=d.get('healthy'),
383            hostname=d.get('hostname'),
384            id=d.get('id'),
385            name=d.get('name'),
386            port=d.get('port'),
387            secret_store_id=d.get('secret_store_id'),
388            tags=d.get('tags'),
389            token=d.get('token'),
390        )
#   AKSServiceAccount( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
295    def __init__(
296        self,
297        egress_filter=None,
298        healthcheck_namespace=None,
299        healthy=None,
300        hostname=None,
301        id=None,
302        name=None,
303        port=None,
304        secret_store_id=None,
305        tags=None,
306        token=None,
307    ):
308        self.egress_filter = egress_filter if egress_filter is not None else ''
309        '''
310         A filter applied to the routing logic to pin datasource to nodes.
311        '''
312        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
313        '''
314         The path used to check the health of your connection.  Defaults to `default`.
315        '''
316        self.healthy = healthy if healthy is not None else False
317        '''
318         True if the datasource is reachable and the credentials are valid.
319        '''
320        self.hostname = hostname if hostname is not None else ''
321        '''
322
323        '''
324        self.id = id if id is not None else ''
325        '''
326         Unique identifier of the Resource.
327        '''
328        self.name = name if name is not None else ''
329        '''
330         Unique human-readable name of the Resource.
331        '''
332        self.port = port if port is not None else 0
333        '''
334
335        '''
336        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
337        '''
338         ID of the secret store containing credentials for this resource, if any.
339        '''
340        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
341        '''
342         Tags is a map of key, value pairs.
343        '''
344        self.token = token if token is not None else ''
345        '''
346
347        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   token
#   def to_dict(self):
View Source
363    def to_dict(self):
364        return {
365            'egress_filter': self.egress_filter,
366            'healthcheck_namespace': self.healthcheck_namespace,
367            'healthy': self.healthy,
368            'hostname': self.hostname,
369            'id': self.id,
370            'name': self.name,
371            'port': self.port,
372            'secret_store_id': self.secret_store_id,
373            'tags': self.tags,
374            'token': self.token,
375        }
#  
@classmethod
def from_dict(cls, d):
View Source
377    @classmethod
378    def from_dict(cls, d):
379        return cls(
380            egress_filter=d.get('egress_filter'),
381            healthcheck_namespace=d.get('healthcheck_namespace'),
382            healthy=d.get('healthy'),
383            hostname=d.get('hostname'),
384            id=d.get('id'),
385            name=d.get('name'),
386            port=d.get('port'),
387            secret_store_id=d.get('secret_store_id'),
388            tags=d.get('tags'),
389            token=d.get('token'),
390        )
#   class AKSServiceAccountUserImpersonation:
View Source
393class AKSServiceAccountUserImpersonation:
394    '''
395
396    '''
397    __slots__ = [
398        'egress_filter',
399        'healthcheck_namespace',
400        'healthy',
401        'hostname',
402        'id',
403        'name',
404        'port',
405        'secret_store_id',
406        'tags',
407        'token',
408    ]
409
410    def __init__(
411        self,
412        egress_filter=None,
413        healthcheck_namespace=None,
414        healthy=None,
415        hostname=None,
416        id=None,
417        name=None,
418        port=None,
419        secret_store_id=None,
420        tags=None,
421        token=None,
422    ):
423        self.egress_filter = egress_filter if egress_filter is not None else ''
424        '''
425         A filter applied to the routing logic to pin datasource to nodes.
426        '''
427        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
428        '''
429         The path used to check the health of your connection.  Defaults to `default`.
430        '''
431        self.healthy = healthy if healthy is not None else False
432        '''
433         True if the datasource is reachable and the credentials are valid.
434        '''
435        self.hostname = hostname if hostname is not None else ''
436        '''
437
438        '''
439        self.id = id if id is not None else ''
440        '''
441         Unique identifier of the Resource.
442        '''
443        self.name = name if name is not None else ''
444        '''
445         Unique human-readable name of the Resource.
446        '''
447        self.port = port if port is not None else 0
448        '''
449
450        '''
451        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
452        '''
453         ID of the secret store containing credentials for this resource, if any.
454        '''
455        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
456        '''
457         Tags is a map of key, value pairs.
458        '''
459        self.token = token if token is not None else ''
460        '''
461
462        '''
463
464    def __repr__(self):
465        return '<sdm.AKSServiceAccountUserImpersonation ' + \
466            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
467            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
468            'healthy: ' + repr(self.healthy) + ' ' +\
469            'hostname: ' + repr(self.hostname) + ' ' +\
470            'id: ' + repr(self.id) + ' ' +\
471            'name: ' + repr(self.name) + ' ' +\
472            'port: ' + repr(self.port) + ' ' +\
473            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
474            'tags: ' + repr(self.tags) + ' ' +\
475            'token: ' + repr(self.token) + ' ' +\
476            '>'
477
478    def to_dict(self):
479        return {
480            'egress_filter': self.egress_filter,
481            'healthcheck_namespace': self.healthcheck_namespace,
482            'healthy': self.healthy,
483            'hostname': self.hostname,
484            'id': self.id,
485            'name': self.name,
486            'port': self.port,
487            'secret_store_id': self.secret_store_id,
488            'tags': self.tags,
489            'token': self.token,
490        }
491
492    @classmethod
493    def from_dict(cls, d):
494        return cls(
495            egress_filter=d.get('egress_filter'),
496            healthcheck_namespace=d.get('healthcheck_namespace'),
497            healthy=d.get('healthy'),
498            hostname=d.get('hostname'),
499            id=d.get('id'),
500            name=d.get('name'),
501            port=d.get('port'),
502            secret_store_id=d.get('secret_store_id'),
503            tags=d.get('tags'),
504            token=d.get('token'),
505        )
#   AKSServiceAccountUserImpersonation( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
410    def __init__(
411        self,
412        egress_filter=None,
413        healthcheck_namespace=None,
414        healthy=None,
415        hostname=None,
416        id=None,
417        name=None,
418        port=None,
419        secret_store_id=None,
420        tags=None,
421        token=None,
422    ):
423        self.egress_filter = egress_filter if egress_filter is not None else ''
424        '''
425         A filter applied to the routing logic to pin datasource to nodes.
426        '''
427        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
428        '''
429         The path used to check the health of your connection.  Defaults to `default`.
430        '''
431        self.healthy = healthy if healthy is not None else False
432        '''
433         True if the datasource is reachable and the credentials are valid.
434        '''
435        self.hostname = hostname if hostname is not None else ''
436        '''
437
438        '''
439        self.id = id if id is not None else ''
440        '''
441         Unique identifier of the Resource.
442        '''
443        self.name = name if name is not None else ''
444        '''
445         Unique human-readable name of the Resource.
446        '''
447        self.port = port if port is not None else 0
448        '''
449
450        '''
451        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
452        '''
453         ID of the secret store containing credentials for this resource, if any.
454        '''
455        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
456        '''
457         Tags is a map of key, value pairs.
458        '''
459        self.token = token if token is not None else ''
460        '''
461
462        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   token
#   def to_dict(self):
View Source
478    def to_dict(self):
479        return {
480            'egress_filter': self.egress_filter,
481            'healthcheck_namespace': self.healthcheck_namespace,
482            'healthy': self.healthy,
483            'hostname': self.hostname,
484            'id': self.id,
485            'name': self.name,
486            'port': self.port,
487            'secret_store_id': self.secret_store_id,
488            'tags': self.tags,
489            'token': self.token,
490        }
#  
@classmethod
def from_dict(cls, d):
View Source
492    @classmethod
493    def from_dict(cls, d):
494        return cls(
495            egress_filter=d.get('egress_filter'),
496            healthcheck_namespace=d.get('healthcheck_namespace'),
497            healthy=d.get('healthy'),
498            hostname=d.get('hostname'),
499            id=d.get('id'),
500            name=d.get('name'),
501            port=d.get('port'),
502            secret_store_id=d.get('secret_store_id'),
503            tags=d.get('tags'),
504            token=d.get('token'),
505        )
#   class AKSUserImpersonation:
View Source
508class AKSUserImpersonation:
509    '''
510
511    '''
512    __slots__ = [
513        'certificate_authority',
514        'client_certificate',
515        'client_key',
516        'egress_filter',
517        'healthcheck_namespace',
518        'healthy',
519        'hostname',
520        'id',
521        'name',
522        'port',
523        'secret_store_id',
524        'tags',
525    ]
526
527    def __init__(
528        self,
529        certificate_authority=None,
530        client_certificate=None,
531        client_key=None,
532        egress_filter=None,
533        healthcheck_namespace=None,
534        healthy=None,
535        hostname=None,
536        id=None,
537        name=None,
538        port=None,
539        secret_store_id=None,
540        tags=None,
541    ):
542        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
543        '''
544
545        '''
546        self.client_certificate = client_certificate if client_certificate is not None else ''
547        '''
548
549        '''
550        self.client_key = client_key if client_key is not None else ''
551        '''
552
553        '''
554        self.egress_filter = egress_filter if egress_filter is not None else ''
555        '''
556         A filter applied to the routing logic to pin datasource to nodes.
557        '''
558        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
559        '''
560         The path used to check the health of your connection.  Defaults to `default`.
561        '''
562        self.healthy = healthy if healthy is not None else False
563        '''
564         True if the datasource is reachable and the credentials are valid.
565        '''
566        self.hostname = hostname if hostname is not None else ''
567        '''
568
569        '''
570        self.id = id if id is not None else ''
571        '''
572         Unique identifier of the Resource.
573        '''
574        self.name = name if name is not None else ''
575        '''
576         Unique human-readable name of the Resource.
577        '''
578        self.port = port if port is not None else 0
579        '''
580
581        '''
582        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
583        '''
584         ID of the secret store containing credentials for this resource, if any.
585        '''
586        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
587        '''
588         Tags is a map of key, value pairs.
589        '''
590
591    def __repr__(self):
592        return '<sdm.AKSUserImpersonation ' + \
593            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
594            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
595            'client_key: ' + repr(self.client_key) + ' ' +\
596            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
597            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
598            'healthy: ' + repr(self.healthy) + ' ' +\
599            'hostname: ' + repr(self.hostname) + ' ' +\
600            'id: ' + repr(self.id) + ' ' +\
601            'name: ' + repr(self.name) + ' ' +\
602            'port: ' + repr(self.port) + ' ' +\
603            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
604            'tags: ' + repr(self.tags) + ' ' +\
605            '>'
606
607    def to_dict(self):
608        return {
609            'certificate_authority': self.certificate_authority,
610            'client_certificate': self.client_certificate,
611            'client_key': self.client_key,
612            'egress_filter': self.egress_filter,
613            'healthcheck_namespace': self.healthcheck_namespace,
614            'healthy': self.healthy,
615            'hostname': self.hostname,
616            'id': self.id,
617            'name': self.name,
618            'port': self.port,
619            'secret_store_id': self.secret_store_id,
620            'tags': self.tags,
621        }
622
623    @classmethod
624    def from_dict(cls, d):
625        return cls(
626            certificate_authority=d.get('certificate_authority'),
627            client_certificate=d.get('client_certificate'),
628            client_key=d.get('client_key'),
629            egress_filter=d.get('egress_filter'),
630            healthcheck_namespace=d.get('healthcheck_namespace'),
631            healthy=d.get('healthy'),
632            hostname=d.get('hostname'),
633            id=d.get('id'),
634            name=d.get('name'),
635            port=d.get('port'),
636            secret_store_id=d.get('secret_store_id'),
637            tags=d.get('tags'),
638        )
#   AKSUserImpersonation( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
527    def __init__(
528        self,
529        certificate_authority=None,
530        client_certificate=None,
531        client_key=None,
532        egress_filter=None,
533        healthcheck_namespace=None,
534        healthy=None,
535        hostname=None,
536        id=None,
537        name=None,
538        port=None,
539        secret_store_id=None,
540        tags=None,
541    ):
542        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
543        '''
544
545        '''
546        self.client_certificate = client_certificate if client_certificate is not None else ''
547        '''
548
549        '''
550        self.client_key = client_key if client_key is not None else ''
551        '''
552
553        '''
554        self.egress_filter = egress_filter if egress_filter is not None else ''
555        '''
556         A filter applied to the routing logic to pin datasource to nodes.
557        '''
558        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
559        '''
560         The path used to check the health of your connection.  Defaults to `default`.
561        '''
562        self.healthy = healthy if healthy is not None else False
563        '''
564         True if the datasource is reachable and the credentials are valid.
565        '''
566        self.hostname = hostname if hostname is not None else ''
567        '''
568
569        '''
570        self.id = id if id is not None else ''
571        '''
572         Unique identifier of the Resource.
573        '''
574        self.name = name if name is not None else ''
575        '''
576         Unique human-readable name of the Resource.
577        '''
578        self.port = port if port is not None else 0
579        '''
580
581        '''
582        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
583        '''
584         ID of the secret store containing credentials for this resource, if any.
585        '''
586        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
587        '''
588         Tags is a map of key, value pairs.
589        '''
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
607    def to_dict(self):
608        return {
609            'certificate_authority': self.certificate_authority,
610            'client_certificate': self.client_certificate,
611            'client_key': self.client_key,
612            'egress_filter': self.egress_filter,
613            'healthcheck_namespace': self.healthcheck_namespace,
614            'healthy': self.healthy,
615            'hostname': self.hostname,
616            'id': self.id,
617            'name': self.name,
618            'port': self.port,
619            'secret_store_id': self.secret_store_id,
620            'tags': self.tags,
621        }
#  
@classmethod
def from_dict(cls, d):
View Source
623    @classmethod
624    def from_dict(cls, d):
625        return cls(
626            certificate_authority=d.get('certificate_authority'),
627            client_certificate=d.get('client_certificate'),
628            client_key=d.get('client_key'),
629            egress_filter=d.get('egress_filter'),
630            healthcheck_namespace=d.get('healthcheck_namespace'),
631            healthy=d.get('healthy'),
632            hostname=d.get('hostname'),
633            id=d.get('id'),
634            name=d.get('name'),
635            port=d.get('port'),
636            secret_store_id=d.get('secret_store_id'),
637            tags=d.get('tags'),
638        )
#   class AWS:
View Source
641class AWS:
642    '''
643
644    '''
645    __slots__ = [
646        'access_key',
647        'egress_filter',
648        'healthcheck_region',
649        'healthy',
650        'id',
651        'name',
652        'role_arn',
653        'role_external_id',
654        'secret_access_key',
655        'secret_store_id',
656        'tags',
657    ]
658
659    def __init__(
660        self,
661        access_key=None,
662        egress_filter=None,
663        healthcheck_region=None,
664        healthy=None,
665        id=None,
666        name=None,
667        role_arn=None,
668        role_external_id=None,
669        secret_access_key=None,
670        secret_store_id=None,
671        tags=None,
672    ):
673        self.access_key = access_key if access_key is not None else ''
674        '''
675
676        '''
677        self.egress_filter = egress_filter if egress_filter is not None else ''
678        '''
679         A filter applied to the routing logic to pin datasource to nodes.
680        '''
681        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
682        '''
683
684        '''
685        self.healthy = healthy if healthy is not None else False
686        '''
687         True if the datasource is reachable and the credentials are valid.
688        '''
689        self.id = id if id is not None else ''
690        '''
691         Unique identifier of the Resource.
692        '''
693        self.name = name if name is not None else ''
694        '''
695         Unique human-readable name of the Resource.
696        '''
697        self.role_arn = role_arn if role_arn is not None else ''
698        '''
699
700        '''
701        self.role_external_id = role_external_id if role_external_id is not None else ''
702        '''
703
704        '''
705        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
706        '''
707
708        '''
709        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
710        '''
711         ID of the secret store containing credentials for this resource, if any.
712        '''
713        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
714        '''
715         Tags is a map of key, value pairs.
716        '''
717
718    def __repr__(self):
719        return '<sdm.AWS ' + \
720            'access_key: ' + repr(self.access_key) + ' ' +\
721            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
722            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
723            'healthy: ' + repr(self.healthy) + ' ' +\
724            'id: ' + repr(self.id) + ' ' +\
725            'name: ' + repr(self.name) + ' ' +\
726            'role_arn: ' + repr(self.role_arn) + ' ' +\
727            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
728            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
730            'tags: ' + repr(self.tags) + ' ' +\
731            '>'
732
733    def to_dict(self):
734        return {
735            'access_key': self.access_key,
736            'egress_filter': self.egress_filter,
737            'healthcheck_region': self.healthcheck_region,
738            'healthy': self.healthy,
739            'id': self.id,
740            'name': self.name,
741            'role_arn': self.role_arn,
742            'role_external_id': self.role_external_id,
743            'secret_access_key': self.secret_access_key,
744            'secret_store_id': self.secret_store_id,
745            'tags': self.tags,
746        }
747
748    @classmethod
749    def from_dict(cls, d):
750        return cls(
751            access_key=d.get('access_key'),
752            egress_filter=d.get('egress_filter'),
753            healthcheck_region=d.get('healthcheck_region'),
754            healthy=d.get('healthy'),
755            id=d.get('id'),
756            name=d.get('name'),
757            role_arn=d.get('role_arn'),
758            role_external_id=d.get('role_external_id'),
759            secret_access_key=d.get('secret_access_key'),
760            secret_store_id=d.get('secret_store_id'),
761            tags=d.get('tags'),
762        )
#   AWS( access_key=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
659    def __init__(
660        self,
661        access_key=None,
662        egress_filter=None,
663        healthcheck_region=None,
664        healthy=None,
665        id=None,
666        name=None,
667        role_arn=None,
668        role_external_id=None,
669        secret_access_key=None,
670        secret_store_id=None,
671        tags=None,
672    ):
673        self.access_key = access_key if access_key is not None else ''
674        '''
675
676        '''
677        self.egress_filter = egress_filter if egress_filter is not None else ''
678        '''
679         A filter applied to the routing logic to pin datasource to nodes.
680        '''
681        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
682        '''
683
684        '''
685        self.healthy = healthy if healthy is not None else False
686        '''
687         True if the datasource is reachable and the credentials are valid.
688        '''
689        self.id = id if id is not None else ''
690        '''
691         Unique identifier of the Resource.
692        '''
693        self.name = name if name is not None else ''
694        '''
695         Unique human-readable name of the Resource.
696        '''
697        self.role_arn = role_arn if role_arn is not None else ''
698        '''
699
700        '''
701        self.role_external_id = role_external_id if role_external_id is not None else ''
702        '''
703
704        '''
705        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
706        '''
707
708        '''
709        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
710        '''
711         ID of the secret store containing credentials for this resource, if any.
712        '''
713        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
714        '''
715         Tags is a map of key, value pairs.
716        '''
#   access_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_region
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
733    def to_dict(self):
734        return {
735            'access_key': self.access_key,
736            'egress_filter': self.egress_filter,
737            'healthcheck_region': self.healthcheck_region,
738            'healthy': self.healthy,
739            'id': self.id,
740            'name': self.name,
741            'role_arn': self.role_arn,
742            'role_external_id': self.role_external_id,
743            'secret_access_key': self.secret_access_key,
744            'secret_store_id': self.secret_store_id,
745            'tags': self.tags,
746        }
#  
@classmethod
def from_dict(cls, d):
View Source
748    @classmethod
749    def from_dict(cls, d):
750        return cls(
751            access_key=d.get('access_key'),
752            egress_filter=d.get('egress_filter'),
753            healthcheck_region=d.get('healthcheck_region'),
754            healthy=d.get('healthy'),
755            id=d.get('id'),
756            name=d.get('name'),
757            role_arn=d.get('role_arn'),
758            role_external_id=d.get('role_external_id'),
759            secret_access_key=d.get('secret_access_key'),
760            secret_store_id=d.get('secret_store_id'),
761            tags=d.get('tags'),
762        )
#   class AWSStore:
View Source
765class AWSStore:
766    '''
767
768    '''
769    __slots__ = [
770        'id',
771        'name',
772        'region',
773        'tags',
774    ]
775
776    def __init__(
777        self,
778        id=None,
779        name=None,
780        region=None,
781        tags=None,
782    ):
783        self.id = id if id is not None else ''
784        '''
785         Unique identifier of the SecretStore.
786        '''
787        self.name = name if name is not None else ''
788        '''
789         Unique human-readable name of the SecretStore.
790        '''
791        self.region = region if region is not None else ''
792        '''
793
794        '''
795        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
796        '''
797         Tags is a map of key, value pairs.
798        '''
799
800    def __repr__(self):
801        return '<sdm.AWSStore ' + \
802            'id: ' + repr(self.id) + ' ' +\
803            'name: ' + repr(self.name) + ' ' +\
804            'region: ' + repr(self.region) + ' ' +\
805            'tags: ' + repr(self.tags) + ' ' +\
806            '>'
807
808    def to_dict(self):
809        return {
810            'id': self.id,
811            'name': self.name,
812            'region': self.region,
813            'tags': self.tags,
814        }
815
816    @classmethod
817    def from_dict(cls, d):
818        return cls(
819            id=d.get('id'),
820            name=d.get('name'),
821            region=d.get('region'),
822            tags=d.get('tags'),
823        )
#   AWSStore(id=None, name=None, region=None, tags=None)
View Source
776    def __init__(
777        self,
778        id=None,
779        name=None,
780        region=None,
781        tags=None,
782    ):
783        self.id = id if id is not None else ''
784        '''
785         Unique identifier of the SecretStore.
786        '''
787        self.name = name if name is not None else ''
788        '''
789         Unique human-readable name of the SecretStore.
790        '''
791        self.region = region if region is not None else ''
792        '''
793
794        '''
795        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
796        '''
797         Tags is a map of key, value pairs.
798        '''
#   id

Unique identifier of the SecretStore.

#   name

Unique human-readable name of the SecretStore.

#   region
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
808    def to_dict(self):
809        return {
810            'id': self.id,
811            'name': self.name,
812            'region': self.region,
813            'tags': self.tags,
814        }
#  
@classmethod
def from_dict(cls, d):
View Source
816    @classmethod
817    def from_dict(cls, d):
818        return cls(
819            id=d.get('id'),
820            name=d.get('name'),
821            region=d.get('region'),
822            tags=d.get('tags'),
823        )
#   class AccountAttachment:
View Source
826class AccountAttachment:
827    '''
828     AccountAttachments assign an account to a role.
829    '''
830    __slots__ = [
831        'account_id',
832        'id',
833        'role_id',
834    ]
835
836    def __init__(
837        self,
838        account_id=None,
839        id=None,
840        role_id=None,
841    ):
842        self.account_id = account_id if account_id is not None else ''
843        '''
844         The id of the account of this AccountAttachment.
845        '''
846        self.id = id if id is not None else ''
847        '''
848         Unique identifier of the AccountAttachment.
849        '''
850        self.role_id = role_id if role_id is not None else ''
851        '''
852         The id of the attached role of this AccountAttachment.
853        '''
854
855    def __repr__(self):
856        return '<sdm.AccountAttachment ' + \
857            'account_id: ' + repr(self.account_id) + ' ' +\
858            'id: ' + repr(self.id) + ' ' +\
859            'role_id: ' + repr(self.role_id) + ' ' +\
860            '>'
861
862    def to_dict(self):
863        return {
864            'account_id': self.account_id,
865            'id': self.id,
866            'role_id': self.role_id,
867        }
868
869    @classmethod
870    def from_dict(cls, d):
871        return cls(
872            account_id=d.get('account_id'),
873            id=d.get('id'),
874            role_id=d.get('role_id'),
875        )

AccountAttachments assign an account to a role.

#   AccountAttachment(account_id=None, id=None, role_id=None)
View Source
836    def __init__(
837        self,
838        account_id=None,
839        id=None,
840        role_id=None,
841    ):
842        self.account_id = account_id if account_id is not None else ''
843        '''
844         The id of the account of this AccountAttachment.
845        '''
846        self.id = id if id is not None else ''
847        '''
848         Unique identifier of the AccountAttachment.
849        '''
850        self.role_id = role_id if role_id is not None else ''
851        '''
852         The id of the attached role of this AccountAttachment.
853        '''
#   account_id

The id of the account of this AccountAttachment.

#   id

Unique identifier of the AccountAttachment.

#   role_id

The id of the attached role of this AccountAttachment.

#   def to_dict(self):
View Source
862    def to_dict(self):
863        return {
864            'account_id': self.account_id,
865            'id': self.id,
866            'role_id': self.role_id,
867        }
#  
@classmethod
def from_dict(cls, d):
View Source
869    @classmethod
870    def from_dict(cls, d):
871        return cls(
872            account_id=d.get('account_id'),
873            id=d.get('id'),
874            role_id=d.get('role_id'),
875        )
#   class AccountAttachmentCreateResponse:
View Source
878class AccountAttachmentCreateResponse:
879    '''
880     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
881    '''
882    __slots__ = [
883        'account_attachment',
884        'meta',
885        'rate_limit',
886    ]
887
888    def __init__(
889        self,
890        account_attachment=None,
891        meta=None,
892        rate_limit=None,
893    ):
894        self.account_attachment = account_attachment if account_attachment is not None else None
895        '''
896         The created AccountAttachment.
897        '''
898        self.meta = meta if meta is not None else None
899        '''
900         Reserved for future use.
901        '''
902        self.rate_limit = rate_limit if rate_limit is not None else None
903        '''
904         Rate limit information.
905        '''
906
907    def __repr__(self):
908        return '<sdm.AccountAttachmentCreateResponse ' + \
909            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
910            'meta: ' + repr(self.meta) + ' ' +\
911            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
912            '>'
913
914    def to_dict(self):
915        return {
916            'account_attachment': self.account_attachment,
917            'meta': self.meta,
918            'rate_limit': self.rate_limit,
919        }
920
921    @classmethod
922    def from_dict(cls, d):
923        return cls(
924            account_attachment=d.get('account_attachment'),
925            meta=d.get('meta'),
926            rate_limit=d.get('rate_limit'),
927        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

#   AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
View Source
888    def __init__(
889        self,
890        account_attachment=None,
891        meta=None,
892        rate_limit=None,
893    ):
894        self.account_attachment = account_attachment if account_attachment is not None else None
895        '''
896         The created AccountAttachment.
897        '''
898        self.meta = meta if meta is not None else None
899        '''
900         Reserved for future use.
901        '''
902        self.rate_limit = rate_limit if rate_limit is not None else None
903        '''
904         Rate limit information.
905        '''
#   account_attachment

The created AccountAttachment.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
914    def to_dict(self):
915        return {
916            'account_attachment': self.account_attachment,
917            'meta': self.meta,
918            'rate_limit': self.rate_limit,
919        }
#  
@classmethod
def from_dict(cls, d):
View Source
921    @classmethod
922    def from_dict(cls, d):
923        return cls(
924            account_attachment=d.get('account_attachment'),
925            meta=d.get('meta'),
926            rate_limit=d.get('rate_limit'),
927        )
#   class AccountAttachmentDeleteResponse:
View Source
930class AccountAttachmentDeleteResponse:
931    '''
932     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
933    '''
934    __slots__ = [
935        'meta',
936        'rate_limit',
937    ]
938
939    def __init__(
940        self,
941        meta=None,
942        rate_limit=None,
943    ):
944        self.meta = meta if meta is not None else None
945        '''
946         Reserved for future use.
947        '''
948        self.rate_limit = rate_limit if rate_limit is not None else None
949        '''
950         Rate limit information.
951        '''
952
953    def __repr__(self):
954        return '<sdm.AccountAttachmentDeleteResponse ' + \
955            'meta: ' + repr(self.meta) + ' ' +\
956            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
957            '>'
958
959    def to_dict(self):
960        return {
961            'meta': self.meta,
962            'rate_limit': self.rate_limit,
963        }
964
965    @classmethod
966    def from_dict(cls, d):
967        return cls(
968            meta=d.get('meta'),
969            rate_limit=d.get('rate_limit'),
970        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

#   AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
View Source
939    def __init__(
940        self,
941        meta=None,
942        rate_limit=None,
943    ):
944        self.meta = meta if meta is not None else None
945        '''
946         Reserved for future use.
947        '''
948        self.rate_limit = rate_limit if rate_limit is not None else None
949        '''
950         Rate limit information.
951        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
959    def to_dict(self):
960        return {
961            'meta': self.meta,
962            'rate_limit': self.rate_limit,
963        }
#  
@classmethod
def from_dict(cls, d):
View Source
965    @classmethod
966    def from_dict(cls, d):
967        return cls(
968            meta=d.get('meta'),
969            rate_limit=d.get('rate_limit'),
970        )
#   class AccountAttachmentGetResponse:
View Source
 973class AccountAttachmentGetResponse:
 974    '''
 975     AccountAttachmentGetResponse returns a requested AccountAttachment.
 976    '''
 977    __slots__ = [
 978        'account_attachment',
 979        'meta',
 980        'rate_limit',
 981    ]
 982
 983    def __init__(
 984        self,
 985        account_attachment=None,
 986        meta=None,
 987        rate_limit=None,
 988    ):
 989        self.account_attachment = account_attachment if account_attachment is not None else None
 990        '''
 991         The requested AccountAttachment.
 992        '''
 993        self.meta = meta if meta is not None else None
 994        '''
 995         Reserved for future use.
 996        '''
 997        self.rate_limit = rate_limit if rate_limit is not None else None
 998        '''
 999         Rate limit information.
1000        '''
1001
1002    def __repr__(self):
1003        return '<sdm.AccountAttachmentGetResponse ' + \
1004            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1005            'meta: ' + repr(self.meta) + ' ' +\
1006            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1007            '>'
1008
1009    def to_dict(self):
1010        return {
1011            'account_attachment': self.account_attachment,
1012            'meta': self.meta,
1013            'rate_limit': self.rate_limit,
1014        }
1015
1016    @classmethod
1017    def from_dict(cls, d):
1018        return cls(
1019            account_attachment=d.get('account_attachment'),
1020            meta=d.get('meta'),
1021            rate_limit=d.get('rate_limit'),
1022        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

#   AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
View Source
 983    def __init__(
 984        self,
 985        account_attachment=None,
 986        meta=None,
 987        rate_limit=None,
 988    ):
 989        self.account_attachment = account_attachment if account_attachment is not None else None
 990        '''
 991         The requested AccountAttachment.
 992        '''
 993        self.meta = meta if meta is not None else None
 994        '''
 995         Reserved for future use.
 996        '''
 997        self.rate_limit = rate_limit if rate_limit is not None else None
 998        '''
 999         Rate limit information.
1000        '''
#   account_attachment

The requested AccountAttachment.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1009    def to_dict(self):
1010        return {
1011            'account_attachment': self.account_attachment,
1012            'meta': self.meta,
1013            'rate_limit': self.rate_limit,
1014        }
#  
@classmethod
def from_dict(cls, d):
View Source
1016    @classmethod
1017    def from_dict(cls, d):
1018        return cls(
1019            account_attachment=d.get('account_attachment'),
1020            meta=d.get('meta'),
1021            rate_limit=d.get('rate_limit'),
1022        )
#   class AccountCreateResponse:
View Source
1025class AccountCreateResponse:
1026    '''
1027     AccountCreateResponse reports how the Accounts were created in the system.
1028    '''
1029    __slots__ = [
1030        'account',
1031        'meta',
1032        'rate_limit',
1033        'token',
1034    ]
1035
1036    def __init__(
1037        self,
1038        account=None,
1039        meta=None,
1040        rate_limit=None,
1041        token=None,
1042    ):
1043        self.account = account if account is not None else None
1044        '''
1045         The created Account.
1046        '''
1047        self.meta = meta if meta is not None else None
1048        '''
1049         Reserved for future use.
1050        '''
1051        self.rate_limit = rate_limit if rate_limit is not None else None
1052        '''
1053         Rate limit information.
1054        '''
1055        self.token = token if token is not None else ''
1056        '''
1057         The auth token generated for the Account. The Account will use this token to
1058         authenticate with the strongDM API.
1059        '''
1060
1061    def __repr__(self):
1062        return '<sdm.AccountCreateResponse ' + \
1063            'account: ' + repr(self.account) + ' ' +\
1064            'meta: ' + repr(self.meta) + ' ' +\
1065            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1066            'token: ' + repr(self.token) + ' ' +\
1067            '>'
1068
1069    def to_dict(self):
1070        return {
1071            'account': self.account,
1072            'meta': self.meta,
1073            'rate_limit': self.rate_limit,
1074            'token': self.token,
1075        }
1076
1077    @classmethod
1078    def from_dict(cls, d):
1079        return cls(
1080            account=d.get('account'),
1081            meta=d.get('meta'),
1082            rate_limit=d.get('rate_limit'),
1083            token=d.get('token'),
1084        )

AccountCreateResponse reports how the Accounts were created in the system.

#   AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
View Source
1036    def __init__(
1037        self,
1038        account=None,
1039        meta=None,
1040        rate_limit=None,
1041        token=None,
1042    ):
1043        self.account = account if account is not None else None
1044        '''
1045         The created Account.
1046        '''
1047        self.meta = meta if meta is not None else None
1048        '''
1049         Reserved for future use.
1050        '''
1051        self.rate_limit = rate_limit if rate_limit is not None else None
1052        '''
1053         Rate limit information.
1054        '''
1055        self.token = token if token is not None else ''
1056        '''
1057         The auth token generated for the Account. The Account will use this token to
1058         authenticate with the strongDM API.
1059        '''
#   account

The created Account.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

#   def to_dict(self):
View Source
1069    def to_dict(self):
1070        return {
1071            'account': self.account,
1072            'meta': self.meta,
1073            'rate_limit': self.rate_limit,
1074            'token': self.token,
1075        }
#  
@classmethod
def from_dict(cls, d):
View Source
1077    @classmethod
1078    def from_dict(cls, d):
1079        return cls(
1080            account=d.get('account'),
1081            meta=d.get('meta'),
1082            rate_limit=d.get('rate_limit'),
1083            token=d.get('token'),
1084        )
#   class AccountDeleteResponse:
View Source
1087class AccountDeleteResponse:
1088    '''
1089     AccountDeleteResponse returns information about a Account that was deleted.
1090    '''
1091    __slots__ = [
1092        'meta',
1093        'rate_limit',
1094    ]
1095
1096    def __init__(
1097        self,
1098        meta=None,
1099        rate_limit=None,
1100    ):
1101        self.meta = meta if meta is not None else None
1102        '''
1103         Reserved for future use.
1104        '''
1105        self.rate_limit = rate_limit if rate_limit is not None else None
1106        '''
1107         Rate limit information.
1108        '''
1109
1110    def __repr__(self):
1111        return '<sdm.AccountDeleteResponse ' + \
1112            'meta: ' + repr(self.meta) + ' ' +\
1113            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1114            '>'
1115
1116    def to_dict(self):
1117        return {
1118            'meta': self.meta,
1119            'rate_limit': self.rate_limit,
1120        }
1121
1122    @classmethod
1123    def from_dict(cls, d):
1124        return cls(
1125            meta=d.get('meta'),
1126            rate_limit=d.get('rate_limit'),
1127        )

AccountDeleteResponse returns information about a Account that was deleted.

#   AccountDeleteResponse(meta=None, rate_limit=None)
View Source
1096    def __init__(
1097        self,
1098        meta=None,
1099        rate_limit=None,
1100    ):
1101        self.meta = meta if meta is not None else None
1102        '''
1103         Reserved for future use.
1104        '''
1105        self.rate_limit = rate_limit if rate_limit is not None else None
1106        '''
1107         Rate limit information.
1108        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1116    def to_dict(self):
1117        return {
1118            'meta': self.meta,
1119            'rate_limit': self.rate_limit,
1120        }
#  
@classmethod
def from_dict(cls, d):
View Source
1122    @classmethod
1123    def from_dict(cls, d):
1124        return cls(
1125            meta=d.get('meta'),
1126            rate_limit=d.get('rate_limit'),
1127        )
#   class AccountGetResponse:
View Source
1130class AccountGetResponse:
1131    '''
1132     AccountGetResponse returns a requested Account.
1133    '''
1134    __slots__ = [
1135        'account',
1136        'meta',
1137        'rate_limit',
1138    ]
1139
1140    def __init__(
1141        self,
1142        account=None,
1143        meta=None,
1144        rate_limit=None,
1145    ):
1146        self.account = account if account is not None else None
1147        '''
1148         The requested Account.
1149        '''
1150        self.meta = meta if meta is not None else None
1151        '''
1152         Reserved for future use.
1153        '''
1154        self.rate_limit = rate_limit if rate_limit is not None else None
1155        '''
1156         Rate limit information.
1157        '''
1158
1159    def __repr__(self):
1160        return '<sdm.AccountGetResponse ' + \
1161            'account: ' + repr(self.account) + ' ' +\
1162            'meta: ' + repr(self.meta) + ' ' +\
1163            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1164            '>'
1165
1166    def to_dict(self):
1167        return {
1168            'account': self.account,
1169            'meta': self.meta,
1170            'rate_limit': self.rate_limit,
1171        }
1172
1173    @classmethod
1174    def from_dict(cls, d):
1175        return cls(
1176            account=d.get('account'),
1177            meta=d.get('meta'),
1178            rate_limit=d.get('rate_limit'),
1179        )

AccountGetResponse returns a requested Account.

#   AccountGetResponse(account=None, meta=None, rate_limit=None)
View Source
1140    def __init__(
1141        self,
1142        account=None,
1143        meta=None,
1144        rate_limit=None,
1145    ):
1146        self.account = account if account is not None else None
1147        '''
1148         The requested Account.
1149        '''
1150        self.meta = meta if meta is not None else None
1151        '''
1152         Reserved for future use.
1153        '''
1154        self.rate_limit = rate_limit if rate_limit is not None else None
1155        '''
1156         Rate limit information.
1157        '''
#   account

The requested Account.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1166    def to_dict(self):
1167        return {
1168            'account': self.account,
1169            'meta': self.meta,
1170            'rate_limit': self.rate_limit,
1171        }
#  
@classmethod
def from_dict(cls, d):
View Source
1173    @classmethod
1174    def from_dict(cls, d):
1175        return cls(
1176            account=d.get('account'),
1177            meta=d.get('meta'),
1178            rate_limit=d.get('rate_limit'),
1179        )
#   class AccountGrant:
View Source
1182class AccountGrant:
1183    '''
1184     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1185    '''
1186    __slots__ = [
1187        'account_id',
1188        'id',
1189        'resource_id',
1190        'start_from',
1191        'valid_until',
1192    ]
1193
1194    def __init__(
1195        self,
1196        account_id=None,
1197        id=None,
1198        resource_id=None,
1199        start_from=None,
1200        valid_until=None,
1201    ):
1202        self.account_id = account_id if account_id is not None else ''
1203        '''
1204         The id of the attached role of this AccountGrant.
1205        '''
1206        self.id = id if id is not None else ''
1207        '''
1208         Unique identifier of the AccountGrant.
1209        '''
1210        self.resource_id = resource_id if resource_id is not None else ''
1211        '''
1212         The id of the composite role of this AccountGrant.
1213        '''
1214        self.start_from = start_from if start_from is not None else None
1215        '''
1216         The timestamp when the resource will be granted. Optional. Both start_at
1217         and end_at must be defined together, or not defined at all.
1218        '''
1219        self.valid_until = valid_until if valid_until is not None else None
1220        '''
1221         The timestamp when the resource grant will expire. Optional. Both
1222         start_at and end_at must be defined together, or not defined at all.
1223        '''
1224
1225    def __repr__(self):
1226        return '<sdm.AccountGrant ' + \
1227            'account_id: ' + repr(self.account_id) + ' ' +\
1228            'id: ' + repr(self.id) + ' ' +\
1229            'resource_id: ' + repr(self.resource_id) + ' ' +\
1230            'start_from: ' + repr(self.start_from) + ' ' +\
1231            'valid_until: ' + repr(self.valid_until) + ' ' +\
1232            '>'
1233
1234    def to_dict(self):
1235        return {
1236            'account_id': self.account_id,
1237            'id': self.id,
1238            'resource_id': self.resource_id,
1239            'start_from': self.start_from,
1240            'valid_until': self.valid_until,
1241        }
1242
1243    @classmethod
1244    def from_dict(cls, d):
1245        return cls(
1246            account_id=d.get('account_id'),
1247            id=d.get('id'),
1248            resource_id=d.get('resource_id'),
1249            start_from=d.get('start_from'),
1250            valid_until=d.get('valid_until'),
1251        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

#   AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None )
View Source
1194    def __init__(
1195        self,
1196        account_id=None,
1197        id=None,
1198        resource_id=None,
1199        start_from=None,
1200        valid_until=None,
1201    ):
1202        self.account_id = account_id if account_id is not None else ''
1203        '''
1204         The id of the attached role of this AccountGrant.
1205        '''
1206        self.id = id if id is not None else ''
1207        '''
1208         Unique identifier of the AccountGrant.
1209        '''
1210        self.resource_id = resource_id if resource_id is not None else ''
1211        '''
1212         The id of the composite role of this AccountGrant.
1213        '''
1214        self.start_from = start_from if start_from is not None else None
1215        '''
1216         The timestamp when the resource will be granted. Optional. Both start_at
1217         and end_at must be defined together, or not defined at all.
1218        '''
1219        self.valid_until = valid_until if valid_until is not None else None
1220        '''
1221         The timestamp when the resource grant will expire. Optional. Both
1222         start_at and end_at must be defined together, or not defined at all.
1223        '''
#   account_id

The id of the attached role of this AccountGrant.

#   id

Unique identifier of the AccountGrant.

#   resource_id

The id of the composite role of this AccountGrant.

#   start_from

The timestamp when the resource will be granted. Optional. Both start_at and end_at must be defined together, or not defined at all.

#   valid_until

The timestamp when the resource grant will expire. Optional. Both start_at and end_at must be defined together, or not defined at all.

#   def to_dict(self):
View Source
1234    def to_dict(self):
1235        return {
1236            'account_id': self.account_id,
1237            'id': self.id,
1238            'resource_id': self.resource_id,
1239            'start_from': self.start_from,
1240            'valid_until': self.valid_until,
1241        }
#  
@classmethod
def from_dict(cls, d):
View Source
1243    @classmethod
1244    def from_dict(cls, d):
1245        return cls(
1246            account_id=d.get('account_id'),
1247            id=d.get('id'),
1248            resource_id=d.get('resource_id'),
1249            start_from=d.get('start_from'),
1250            valid_until=d.get('valid_until'),
1251        )
#   class AccountGrantCreateResponse:
View Source
1254class AccountGrantCreateResponse:
1255    '''
1256     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1257    '''
1258    __slots__ = [
1259        'account_grant',
1260        'meta',
1261        'rate_limit',
1262    ]
1263
1264    def __init__(
1265        self,
1266        account_grant=None,
1267        meta=None,
1268        rate_limit=None,
1269    ):
1270        self.account_grant = account_grant if account_grant is not None else None
1271        '''
1272         The created AccountGrant.
1273        '''
1274        self.meta = meta if meta is not None else None
1275        '''
1276         Reserved for future use.
1277        '''
1278        self.rate_limit = rate_limit if rate_limit is not None else None
1279        '''
1280         Rate limit information.
1281        '''
1282
1283    def __repr__(self):
1284        return '<sdm.AccountGrantCreateResponse ' + \
1285            'account_grant: ' + repr(self.account_grant) + ' ' +\
1286            'meta: ' + repr(self.meta) + ' ' +\
1287            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1288            '>'
1289
1290    def to_dict(self):
1291        return {
1292            'account_grant': self.account_grant,
1293            'meta': self.meta,
1294            'rate_limit': self.rate_limit,
1295        }
1296
1297    @classmethod
1298    def from_dict(cls, d):
1299        return cls(
1300            account_grant=d.get('account_grant'),
1301            meta=d.get('meta'),
1302            rate_limit=d.get('rate_limit'),
1303        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

#   AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
View Source
1264    def __init__(
1265        self,
1266        account_grant=None,
1267        meta=None,
1268        rate_limit=None,
1269    ):
1270        self.account_grant = account_grant if account_grant is not None else None
1271        '''
1272         The created AccountGrant.
1273        '''
1274        self.meta = meta if meta is not None else None
1275        '''
1276         Reserved for future use.
1277        '''
1278        self.rate_limit = rate_limit if rate_limit is not None else None
1279        '''
1280         Rate limit information.
1281        '''
#   account_grant

The created AccountGrant.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1290    def to_dict(self):
1291        return {
1292            'account_grant': self.account_grant,
1293            'meta': self.meta,
1294            'rate_limit': self.rate_limit,
1295        }
#  
@classmethod
def from_dict(cls, d):
View Source
1297    @classmethod
1298    def from_dict(cls, d):
1299        return cls(
1300            account_grant=d.get('account_grant'),
1301            meta=d.get('meta'),
1302            rate_limit=d.get('rate_limit'),
1303        )
#   class AccountGrantDeleteResponse:
View Source
1306class AccountGrantDeleteResponse:
1307    '''
1308     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1309    '''
1310    __slots__ = [
1311        'meta',
1312        'rate_limit',
1313    ]
1314
1315    def __init__(
1316        self,
1317        meta=None,
1318        rate_limit=None,
1319    ):
1320        self.meta = meta if meta is not None else None
1321        '''
1322         Reserved for future use.
1323        '''
1324        self.rate_limit = rate_limit if rate_limit is not None else None
1325        '''
1326         Rate limit information.
1327        '''
1328
1329    def __repr__(self):
1330        return '<sdm.AccountGrantDeleteResponse ' + \
1331            'meta: ' + repr(self.meta) + ' ' +\
1332            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1333            '>'
1334
1335    def to_dict(self):
1336        return {
1337            'meta': self.meta,
1338            'rate_limit': self.rate_limit,
1339        }
1340
1341    @classmethod
1342    def from_dict(cls, d):
1343        return cls(
1344            meta=d.get('meta'),
1345            rate_limit=d.get('rate_limit'),
1346        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

#   AccountGrantDeleteResponse(meta=None, rate_limit=None)
View Source
1315    def __init__(
1316        self,
1317        meta=None,
1318        rate_limit=None,
1319    ):
1320        self.meta = meta if meta is not None else None
1321        '''
1322         Reserved for future use.
1323        '''
1324        self.rate_limit = rate_limit if rate_limit is not None else None
1325        '''
1326         Rate limit information.
1327        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1335    def to_dict(self):
1336        return {
1337            'meta': self.meta,
1338            'rate_limit': self.rate_limit,
1339        }
#  
@classmethod
def from_dict(cls, d):
View Source
1341    @classmethod
1342    def from_dict(cls, d):
1343        return cls(
1344            meta=d.get('meta'),
1345            rate_limit=d.get('rate_limit'),
1346        )
#   class AccountGrantGetResponse:
View Source
1349class AccountGrantGetResponse:
1350    '''
1351     AccountGrantGetResponse returns a requested AccountGrant.
1352    '''
1353    __slots__ = [
1354        'account_grant',
1355        'meta',
1356        'rate_limit',
1357    ]
1358
1359    def __init__(
1360        self,
1361        account_grant=None,
1362        meta=None,
1363        rate_limit=None,
1364    ):
1365        self.account_grant = account_grant if account_grant is not None else None
1366        '''
1367         The requested AccountGrant.
1368        '''
1369        self.meta = meta if meta is not None else None
1370        '''
1371         Reserved for future use.
1372        '''
1373        self.rate_limit = rate_limit if rate_limit is not None else None
1374        '''
1375         Rate limit information.
1376        '''
1377
1378    def __repr__(self):
1379        return '<sdm.AccountGrantGetResponse ' + \
1380            'account_grant: ' + repr(self.account_grant) + ' ' +\
1381            'meta: ' + repr(self.meta) + ' ' +\
1382            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1383            '>'
1384
1385    def to_dict(self):
1386        return {
1387            'account_grant': self.account_grant,
1388            'meta': self.meta,
1389            'rate_limit': self.rate_limit,
1390        }
1391
1392    @classmethod
1393    def from_dict(cls, d):
1394        return cls(
1395            account_grant=d.get('account_grant'),
1396            meta=d.get('meta'),
1397            rate_limit=d.get('rate_limit'),
1398        )

AccountGrantGetResponse returns a requested AccountGrant.

#   AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
View Source
1359    def __init__(
1360        self,
1361        account_grant=None,
1362        meta=None,
1363        rate_limit=None,
1364    ):
1365        self.account_grant = account_grant if account_grant is not None else None
1366        '''
1367         The requested AccountGrant.
1368        '''
1369        self.meta = meta if meta is not None else None
1370        '''
1371         Reserved for future use.
1372        '''
1373        self.rate_limit = rate_limit if rate_limit is not None else None
1374        '''
1375         Rate limit information.
1376        '''
#   account_grant

The requested AccountGrant.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1385    def to_dict(self):
1386        return {
1387            'account_grant': self.account_grant,
1388            'meta': self.meta,
1389            'rate_limit': self.rate_limit,
1390        }
#  
@classmethod
def from_dict(cls, d):
View Source
1392    @classmethod
1393    def from_dict(cls, d):
1394        return cls(
1395            account_grant=d.get('account_grant'),
1396            meta=d.get('meta'),
1397            rate_limit=d.get('rate_limit'),
1398        )
#   class AccountUpdateResponse:
View Source
1401class AccountUpdateResponse:
1402    '''
1403     AccountUpdateResponse returns the fields of a Account after it has been updated by
1404     a AccountUpdateRequest.
1405    '''
1406    __slots__ = [
1407        'account',
1408        'meta',
1409        'rate_limit',
1410    ]
1411
1412    def __init__(
1413        self,
1414        account=None,
1415        meta=None,
1416        rate_limit=None,
1417    ):
1418        self.account = account if account is not None else None
1419        '''
1420         The updated Account.
1421        '''
1422        self.meta = meta if meta is not None else None
1423        '''
1424         Reserved for future use.
1425        '''
1426        self.rate_limit = rate_limit if rate_limit is not None else None
1427        '''
1428         Rate limit information.
1429        '''
1430
1431    def __repr__(self):
1432        return '<sdm.AccountUpdateResponse ' + \
1433            'account: ' + repr(self.account) + ' ' +\
1434            'meta: ' + repr(self.meta) + ' ' +\
1435            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1436            '>'
1437
1438    def to_dict(self):
1439        return {
1440            'account': self.account,
1441            'meta': self.meta,
1442            'rate_limit': self.rate_limit,
1443        }
1444
1445    @classmethod
1446    def from_dict(cls, d):
1447        return cls(
1448            account=d.get('account'),
1449            meta=d.get('meta'),
1450            rate_limit=d.get('rate_limit'),
1451        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

#   AccountUpdateResponse(account=None, meta=None, rate_limit=None)
View Source
1412    def __init__(
1413        self,
1414        account=None,
1415        meta=None,
1416        rate_limit=None,
1417    ):
1418        self.account = account if account is not None else None
1419        '''
1420         The updated Account.
1421        '''
1422        self.meta = meta if meta is not None else None
1423        '''
1424         Reserved for future use.
1425        '''
1426        self.rate_limit = rate_limit if rate_limit is not None else None
1427        '''
1428         Rate limit information.
1429        '''
#   account

The updated Account.

#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
1438    def to_dict(self):
1439        return {
1440            'account': self.account,
1441            'meta': self.meta,
1442            'rate_limit': self.rate_limit,
1443        }
#  
@classmethod
def from_dict(cls, d):
View Source
1445    @classmethod
1446    def from_dict(cls, d):
1447        return cls(
1448            account=d.get('account'),
1449            meta=d.get('meta'),
1450            rate_limit=d.get('rate_limit'),
1451        )
#   class AmazonEKS:
View Source
1454class AmazonEKS:
1455    '''
1456
1457    '''
1458    __slots__ = [
1459        'access_key',
1460        'certificate_authority',
1461        'cluster_name',
1462        'egress_filter',
1463        'endpoint',
1464        'healthcheck_namespace',
1465        'healthy',
1466        'id',
1467        'name',
1468        'region',
1469        'role_arn',
1470        'role_external_id',
1471        'secret_access_key',
1472        'secret_store_id',
1473        'tags',
1474    ]
1475
1476    def __init__(
1477        self,
1478        access_key=None,
1479        certificate_authority=None,
1480        cluster_name=None,
1481        egress_filter=None,
1482        endpoint=None,
1483        healthcheck_namespace=None,
1484        healthy=None,
1485        id=None,
1486        name=None,
1487        region=None,
1488        role_arn=None,
1489        role_external_id=None,
1490        secret_access_key=None,
1491        secret_store_id=None,
1492        tags=None,
1493    ):
1494        self.access_key = access_key if access_key is not None else ''
1495        '''
1496
1497        '''
1498        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1499        '''
1500
1501        '''
1502        self.cluster_name = cluster_name if cluster_name is not None else ''
1503        '''
1504
1505        '''
1506        self.egress_filter = egress_filter if egress_filter is not None else ''
1507        '''
1508         A filter applied to the routing logic to pin datasource to nodes.
1509        '''
1510        self.endpoint = endpoint if endpoint is not None else ''
1511        '''
1512
1513        '''
1514        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1515        '''
1516         The path used to check the health of your connection.  Defaults to `default`.
1517        '''
1518        self.healthy = healthy if healthy is not None else False
1519        '''
1520         True if the datasource is reachable and the credentials are valid.
1521        '''
1522        self.id = id if id is not None else ''
1523        '''
1524         Unique identifier of the Resource.
1525        '''
1526        self.name = name if name is not None else ''
1527        '''
1528         Unique human-readable name of the Resource.
1529        '''
1530        self.region = region if region is not None else ''
1531        '''
1532
1533        '''
1534        self.role_arn = role_arn if role_arn is not None else ''
1535        '''
1536
1537        '''
1538        self.role_external_id = role_external_id if role_external_id is not None else ''
1539        '''
1540
1541        '''
1542        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1543        '''
1544
1545        '''
1546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1547        '''
1548         ID of the secret store containing credentials for this resource, if any.
1549        '''
1550        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1551        '''
1552         Tags is a map of key, value pairs.
1553        '''
1554
1555    def __repr__(self):
1556        return '<sdm.AmazonEKS ' + \
1557            'access_key: ' + repr(self.access_key) + ' ' +\
1558            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1559            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1560            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1561            'endpoint: ' + repr(self.endpoint) + ' ' +\
1562            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1563            'healthy: ' + repr(self.healthy) + ' ' +\
1564            'id: ' + repr(self.id) + ' ' +\
1565            'name: ' + repr(self.name) + ' ' +\
1566            'region: ' + repr(self.region) + ' ' +\
1567            'role_arn: ' + repr(self.role_arn) + ' ' +\
1568            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1569            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1570            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1571            'tags: ' + repr(self.tags) + ' ' +\
1572            '>'
1573
1574    def to_dict(self):
1575        return {
1576            'access_key': self.access_key,
1577            'certificate_authority': self.certificate_authority,
1578            'cluster_name': self.cluster_name,
1579            'egress_filter': self.egress_filter,
1580            'endpoint': self.endpoint,
1581            'healthcheck_namespace': self.healthcheck_namespace,
1582            'healthy': self.healthy,
1583            'id': self.id,
1584            'name': self.name,
1585            'region': self.region,
1586            'role_arn': self.role_arn,
1587            'role_external_id': self.role_external_id,
1588            'secret_access_key': self.secret_access_key,
1589            'secret_store_id': self.secret_store_id,
1590            'tags': self.tags,
1591        }
1592
1593    @classmethod
1594    def from_dict(cls, d):
1595        return cls(
1596            access_key=d.get('access_key'),
1597            certificate_authority=d.get('certificate_authority'),
1598            cluster_name=d.get('cluster_name'),
1599            egress_filter=d.get('egress_filter'),
1600            endpoint=d.get('endpoint'),
1601            healthcheck_namespace=d.get('healthcheck_namespace'),
1602            healthy=d.get('healthy'),
1603            id=d.get('id'),
1604            name=d.get('name'),
1605            region=d.get('region'),
1606            role_arn=d.get('role_arn'),
1607            role_external_id=d.get('role_external_id'),
1608            secret_access_key=d.get('secret_access_key'),
1609            secret_store_id=d.get('secret_store_id'),
1610            tags=d.get('tags'),
1611        )
#   AmazonEKS( access_key=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
1476    def __init__(
1477        self,
1478        access_key=None,
1479        certificate_authority=None,
1480        cluster_name=None,
1481        egress_filter=None,
1482        endpoint=None,
1483        healthcheck_namespace=None,
1484        healthy=None,
1485        id=None,
1486        name=None,
1487        region=None,
1488        role_arn=None,
1489        role_external_id=None,
1490        secret_access_key=None,
1491        secret_store_id=None,
1492        tags=None,
1493    ):
1494        self.access_key = access_key if access_key is not None else ''
1495        '''
1496
1497        '''
1498        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1499        '''
1500
1501        '''
1502        self.cluster_name = cluster_name if cluster_name is not None else ''
1503        '''
1504
1505        '''
1506        self.egress_filter = egress_filter if egress_filter is not None else ''
1507        '''
1508         A filter applied to the routing logic to pin datasource to nodes.
1509        '''
1510        self.endpoint = endpoint if endpoint is not None else ''
1511        '''
1512
1513        '''
1514        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1515        '''
1516         The path used to check the health of your connection.  Defaults to `default`.
1517        '''
1518        self.healthy = healthy if healthy is not None else False
1519        '''
1520         True if the datasource is reachable and the credentials are valid.
1521        '''
1522        self.id = id if id is not None else ''
1523        '''
1524         Unique identifier of the Resource.
1525        '''
1526        self.name = name if name is not None else ''
1527        '''
1528         Unique human-readable name of the Resource.
1529        '''
1530        self.region = region if region is not None else ''
1531        '''
1532
1533        '''
1534        self.role_arn = role_arn if role_arn is not None else ''
1535        '''
1536
1537        '''
1538        self.role_external_id = role_external_id if role_external_id is not None else ''
1539        '''
1540
1541        '''
1542        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1543        '''
1544
1545        '''
1546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1547        '''
1548         ID of the secret store containing credentials for this resource, if any.
1549        '''
1550        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1551        '''
1552         Tags is a map of key, value pairs.
1553        '''
#   access_key
#   certificate_authority
#   cluster_name
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
1574    def to_dict(self):
1575        return {
1576            'access_key': self.access_key,
1577            'certificate_authority': self.certificate_authority,
1578            'cluster_name': self.cluster_name,
1579            'egress_filter': self.egress_filter,
1580            'endpoint': self.endpoint,
1581            'healthcheck_namespace': self.healthcheck_namespace,
1582            'healthy': self.healthy,
1583            'id': self.id,
1584            'name': self.name,
1585            'region': self.region,
1586            'role_arn': self.role_arn,
1587            'role_external_id': self.role_external_id,
1588            'secret_access_key': self.secret_access_key,
1589            'secret_store_id': self.secret_store_id,
1590            'tags': self.tags,
1591        }
#  
@classmethod
def from_dict(cls, d):
View Source
1593    @classmethod
1594    def from_dict(cls, d):
1595        return cls(
1596            access_key=d.get('access_key'),
1597            certificate_authority=d.get('certificate_authority'),
1598            cluster_name=d.get('cluster_name'),
1599            egress_filter=d.get('egress_filter'),
1600            endpoint=d.get('endpoint'),
1601            healthcheck_namespace=d.get('healthcheck_namespace'),
1602            healthy=d.get('healthy'),
1603            id=d.get('id'),
1604            name=d.get('name'),
1605            region=d.get('region'),
1606            role_arn=d.get('role_arn'),
1607            role_external_id=d.get('role_external_id'),
1608            secret_access_key=d.get('secret_access_key'),
1609            secret_store_id=d.get('secret_store_id'),
1610            tags=d.get('tags'),
1611        )
#   class AmazonEKSUserImpersonation:
View Source
1614class AmazonEKSUserImpersonation:
1615    '''
1616
1617    '''
1618    __slots__ = [
1619        'access_key',
1620        'certificate_authority',
1621        'cluster_name',
1622        'egress_filter',
1623        'endpoint',
1624        'healthcheck_namespace',
1625        'healthy',
1626        'id',
1627        'name',
1628        'region',
1629        'role_arn',
1630        'role_external_id',
1631        'secret_access_key',
1632        'secret_store_id',
1633        'tags',
1634    ]
1635
1636    def __init__(
1637        self,
1638        access_key=None,
1639        certificate_authority=None,
1640        cluster_name=None,
1641        egress_filter=None,
1642        endpoint=None,
1643        healthcheck_namespace=None,
1644        healthy=None,
1645        id=None,
1646        name=None,
1647        region=None,
1648        role_arn=None,
1649        role_external_id=None,
1650        secret_access_key=None,
1651        secret_store_id=None,
1652        tags=None,
1653    ):
1654        self.access_key = access_key if access_key is not None else ''
1655        '''
1656
1657        '''
1658        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1659        '''
1660
1661        '''
1662        self.cluster_name = cluster_name if cluster_name is not None else ''
1663        '''
1664
1665        '''
1666        self.egress_filter = egress_filter if egress_filter is not None else ''
1667        '''
1668         A filter applied to the routing logic to pin datasource to nodes.
1669        '''
1670        self.endpoint = endpoint if endpoint is not None else ''
1671        '''
1672
1673        '''
1674        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1675        '''
1676         The path used to check the health of your connection.  Defaults to `default`.
1677        '''
1678        self.healthy = healthy if healthy is not None else False
1679        '''
1680         True if the datasource is reachable and the credentials are valid.
1681        '''
1682        self.id = id if id is not None else ''
1683        '''
1684         Unique identifier of the Resource.
1685        '''
1686        self.name = name if name is not None else ''
1687        '''
1688         Unique human-readable name of the Resource.
1689        '''
1690        self.region = region if region is not None else ''
1691        '''
1692
1693        '''
1694        self.role_arn = role_arn if role_arn is not None else ''
1695        '''
1696
1697        '''
1698        self.role_external_id = role_external_id if role_external_id is not None else ''
1699        '''
1700
1701        '''
1702        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1703        '''
1704
1705        '''
1706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1707        '''
1708         ID of the secret store containing credentials for this resource, if any.
1709        '''
1710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1711        '''
1712         Tags is a map of key, value pairs.
1713        '''
1714
1715    def __repr__(self):
1716        return '<sdm.AmazonEKSUserImpersonation ' + \
1717            'access_key: ' + repr(self.access_key) + ' ' +\
1718            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1719            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1720            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1721            'endpoint: ' + repr(self.endpoint) + ' ' +\
1722            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1723            'healthy: ' + repr(self.healthy) + ' ' +\
1724            'id: ' + repr(self.id) + ' ' +\
1725            'name: ' + repr(self.name) + ' ' +\
1726            'region: ' + repr(self.region) + ' ' +\
1727            'role_arn: ' + repr(self.role_arn) + ' ' +\
1728            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1729            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1731            'tags: ' + repr(self.tags) + ' ' +\
1732            '>'
1733
1734    def to_dict(self):
1735        return {
1736            'access_key': self.access_key,
1737            'certificate_authority': self.certificate_authority,
1738            'cluster_name': self.cluster_name,
1739            'egress_filter': self.egress_filter,
1740            'endpoint': self.endpoint,
1741            'healthcheck_namespace': self.healthcheck_namespace,
1742            'healthy': self.healthy,
1743            'id': self.id,
1744            'name': self.name,
1745            'region': self.region,
1746            'role_arn': self.role_arn,
1747            'role_external_id': self.role_external_id,
1748            'secret_access_key': self.secret_access_key,
1749            'secret_store_id': self.secret_store_id,
1750            'tags': self.tags,
1751        }
1752
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            access_key=d.get('access_key'),
1757            certificate_authority=d.get('certificate_authority'),
1758            cluster_name=d.get('cluster_name'),
1759            egress_filter=d.get('egress_filter'),
1760            endpoint=d.get('endpoint'),
1761            healthcheck_namespace=d.get('healthcheck_namespace'),
1762            healthy=d.get('healthy'),
1763            id=d.get('id'),
1764            name=d.get('name'),
1765            region=d.get('region'),
1766            role_arn=d.get('role_arn'),
1767            role_external_id=d.get('role_external_id'),
1768            secret_access_key=d.get('secret_access_key'),
1769            secret_store_id=d.get('secret_store_id'),
1770            tags=d.get('tags'),
1771        )
#   AmazonEKSUserImpersonation( access_key=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
1636    def __init__(
1637        self,
1638        access_key=None,
1639        certificate_authority=None,
1640        cluster_name=None,
1641        egress_filter=None,
1642        endpoint=None,
1643        healthcheck_namespace=None,
1644        healthy=None,
1645        id=None,
1646        name=None,
1647        region=None,
1648        role_arn=None,
1649        role_external_id=None,
1650        secret_access_key=None,
1651        secret_store_id=None,
1652        tags=None,
1653    ):
1654        self.access_key = access_key if access_key is not None else ''
1655        '''
1656
1657        '''
1658        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1659        '''
1660
1661        '''
1662        self.cluster_name = cluster_name if cluster_name is not None else ''
1663        '''
1664
1665        '''
1666        self.egress_filter = egress_filter if egress_filter is not None else ''
1667        '''
1668         A filter applied to the routing logic to pin datasource to nodes.
1669        '''
1670        self.endpoint = endpoint if endpoint is not None else ''
1671        '''
1672
1673        '''
1674        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1675        '''
1676         The path used to check the health of your connection.  Defaults to `default`.
1677        '''
1678        self.healthy = healthy if healthy is not None else False
1679        '''
1680         True if the datasource is reachable and the credentials are valid.
1681        '''
1682        self.id = id if id is not None else ''
1683        '''
1684         Unique identifier of the Resource.
1685        '''
1686        self.name = name if name is not None else ''
1687        '''
1688         Unique human-readable name of the Resource.
1689        '''
1690        self.region = region if region is not None else ''
1691        '''
1692
1693        '''
1694        self.role_arn = role_arn if role_arn is not None else ''
1695        '''
1696
1697        '''
1698        self.role_external_id = role_external_id if role_external_id is not None else ''
1699        '''
1700
1701        '''
1702        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1703        '''
1704
1705        '''
1706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1707        '''
1708         ID of the secret store containing credentials for this resource, if any.
1709        '''
1710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1711        '''
1712         Tags is a map of key, value pairs.
1713        '''
#   access_key
#   certificate_authority
#   cluster_name
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
1734    def to_dict(self):
1735        return {
1736            'access_key': self.access_key,
1737            'certificate_authority': self.certificate_authority,
1738            'cluster_name': self.cluster_name,
1739            'egress_filter': self.egress_filter,
1740            'endpoint': self.endpoint,
1741            'healthcheck_namespace': self.healthcheck_namespace,
1742            'healthy': self.healthy,
1743            'id': self.id,
1744            'name': self.name,
1745            'region': self.region,
1746            'role_arn': self.role_arn,
1747            'role_external_id': self.role_external_id,
1748            'secret_access_key': self.secret_access_key,
1749            'secret_store_id': self.secret_store_id,
1750            'tags': self.tags,
1751        }
#  
@classmethod
def from_dict(cls, d):
View Source
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            access_key=d.get('access_key'),
1757            certificate_authority=d.get('certificate_authority'),
1758            cluster_name=d.get('cluster_name'),
1759            egress_filter=d.get('egress_filter'),
1760            endpoint=d.get('endpoint'),
1761            healthcheck_namespace=d.get('healthcheck_namespace'),
1762            healthy=d.get('healthy'),
1763            id=d.get('id'),
1764            name=d.get('name'),
1765            region=d.get('region'),
1766            role_arn=d.get('role_arn'),
1767            role_external_id=d.get('role_external_id'),
1768            secret_access_key=d.get('secret_access_key'),
1769            secret_store_id=d.get('secret_store_id'),
1770            tags=d.get('tags'),
1771        )
#   class AmazonES:
View Source
1774class AmazonES:
1775    '''
1776
1777    '''
1778    __slots__ = [
1779        'access_key',
1780        'egress_filter',
1781        'endpoint',
1782        'healthy',
1783        'id',
1784        'name',
1785        'port_override',
1786        'region',
1787        'role_arn',
1788        'role_external_id',
1789        'secret_access_key',
1790        'secret_store_id',
1791        'tags',
1792    ]
1793
1794    def __init__(
1795        self,
1796        access_key=None,
1797        egress_filter=None,
1798        endpoint=None,
1799        healthy=None,
1800        id=None,
1801        name=None,
1802        port_override=None,
1803        region=None,
1804        role_arn=None,
1805        role_external_id=None,
1806        secret_access_key=None,
1807        secret_store_id=None,
1808        tags=None,
1809    ):
1810        self.access_key = access_key if access_key is not None else ''
1811        '''
1812
1813        '''
1814        self.egress_filter = egress_filter if egress_filter is not None else ''
1815        '''
1816         A filter applied to the routing logic to pin datasource to nodes.
1817        '''
1818        self.endpoint = endpoint if endpoint is not None else ''
1819        '''
1820
1821        '''
1822        self.healthy = healthy if healthy is not None else False
1823        '''
1824         True if the datasource is reachable and the credentials are valid.
1825        '''
1826        self.id = id if id is not None else ''
1827        '''
1828         Unique identifier of the Resource.
1829        '''
1830        self.name = name if name is not None else ''
1831        '''
1832         Unique human-readable name of the Resource.
1833        '''
1834        self.port_override = port_override if port_override is not None else 0
1835        '''
1836
1837        '''
1838        self.region = region if region is not None else ''
1839        '''
1840
1841        '''
1842        self.role_arn = role_arn if role_arn is not None else ''
1843        '''
1844
1845        '''
1846        self.role_external_id = role_external_id if role_external_id is not None else ''
1847        '''
1848
1849        '''
1850        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1851        '''
1852
1853        '''
1854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1855        '''
1856         ID of the secret store containing credentials for this resource, if any.
1857        '''
1858        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1859        '''
1860         Tags is a map of key, value pairs.
1861        '''
1862
1863    def __repr__(self):
1864        return '<sdm.AmazonES ' + \
1865            'access_key: ' + repr(self.access_key) + ' ' +\
1866            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1867            'endpoint: ' + repr(self.endpoint) + ' ' +\
1868            'healthy: ' + repr(self.healthy) + ' ' +\
1869            'id: ' + repr(self.id) + ' ' +\
1870            'name: ' + repr(self.name) + ' ' +\
1871            'port_override: ' + repr(self.port_override) + ' ' +\
1872            'region: ' + repr(self.region) + ' ' +\
1873            'role_arn: ' + repr(self.role_arn) + ' ' +\
1874            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1875            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1876            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1877            'tags: ' + repr(self.tags) + ' ' +\
1878            '>'
1879
1880    def to_dict(self):
1881        return {
1882            'access_key': self.access_key,
1883            'egress_filter': self.egress_filter,
1884            'endpoint': self.endpoint,
1885            'healthy': self.healthy,
1886            'id': self.id,
1887            'name': self.name,
1888            'port_override': self.port_override,
1889            'region': self.region,
1890            'role_arn': self.role_arn,
1891            'role_external_id': self.role_external_id,
1892            'secret_access_key': self.secret_access_key,
1893            'secret_store_id': self.secret_store_id,
1894            'tags': self.tags,
1895        }
1896
1897    @classmethod
1898    def from_dict(cls, d):
1899        return cls(
1900            access_key=d.get('access_key'),
1901            egress_filter=d.get('egress_filter'),
1902            endpoint=d.get('endpoint'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            port_override=d.get('port_override'),
1907            region=d.get('region'),
1908            role_arn=d.get('role_arn'),
1909            role_external_id=d.get('role_external_id'),
1910            secret_access_key=d.get('secret_access_key'),
1911            secret_store_id=d.get('secret_store_id'),
1912            tags=d.get('tags'),
1913        )
#   AmazonES( access_key=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
1794    def __init__(
1795        self,
1796        access_key=None,
1797        egress_filter=None,
1798        endpoint=None,
1799        healthy=None,
1800        id=None,
1801        name=None,
1802        port_override=None,
1803        region=None,
1804        role_arn=None,
1805        role_external_id=None,
1806        secret_access_key=None,
1807        secret_store_id=None,
1808        tags=None,
1809    ):
1810        self.access_key = access_key if access_key is not None else ''
1811        '''
1812
1813        '''
1814        self.egress_filter = egress_filter if egress_filter is not None else ''
1815        '''
1816         A filter applied to the routing logic to pin datasource to nodes.
1817        '''
1818        self.endpoint = endpoint if endpoint is not None else ''
1819        '''
1820
1821        '''
1822        self.healthy = healthy if healthy is not None else False
1823        '''
1824         True if the datasource is reachable and the credentials are valid.
1825        '''
1826        self.id = id if id is not None else ''
1827        '''
1828         Unique identifier of the Resource.
1829        '''
1830        self.name = name if name is not None else ''
1831        '''
1832         Unique human-readable name of the Resource.
1833        '''
1834        self.port_override = port_override if port_override is not None else 0
1835        '''
1836
1837        '''
1838        self.region = region if region is not None else ''
1839        '''
1840
1841        '''
1842        self.role_arn = role_arn if role_arn is not None else ''
1843        '''
1844
1845        '''
1846        self.role_external_id = role_external_id if role_external_id is not None else ''
1847        '''
1848
1849        '''
1850        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1851        '''
1852
1853        '''
1854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1855        '''
1856         ID of the secret store containing credentials for this resource, if any.
1857        '''
1858        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1859        '''
1860         Tags is a map of key, value pairs.
1861        '''
#   access_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
1880    def to_dict(self):
1881        return {
1882            'access_key': self.access_key,
1883            'egress_filter': self.egress_filter,
1884            'endpoint': self.endpoint,
1885            'healthy': self.healthy,
1886            'id': self.id,
1887            'name': self.name,
1888            'port_override': self.port_override,
1889            'region': self.region,
1890            'role_arn': self.role_arn,
1891            'role_external_id': self.role_external_id,
1892            'secret_access_key': self.secret_access_key,
1893            'secret_store_id': self.secret_store_id,
1894            'tags': self.tags,
1895        }
#  
@classmethod
def from_dict(cls, d):
View Source
1897    @classmethod
1898    def from_dict(cls, d):
1899        return cls(
1900            access_key=d.get('access_key'),
1901            egress_filter=d.get('egress_filter'),
1902            endpoint=d.get('endpoint'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            port_override=d.get('port_override'),
1907            region=d.get('region'),
1908            role_arn=d.get('role_arn'),
1909            role_external_id=d.get('role_external_id'),
1910            secret_access_key=d.get('secret_access_key'),
1911            secret_store_id=d.get('secret_store_id'),
1912            tags=d.get('tags'),
1913        )
#   class AmazonMQAMQP091:
View Source
1916class AmazonMQAMQP091:
1917    '''
1918
1919    '''
1920    __slots__ = [
1921        'egress_filter',
1922        'healthy',
1923        'hostname',
1924        'id',
1925        'name',
1926        'password',
1927        'port',
1928        'port_override',
1929        'secret_store_id',
1930        'tags',
1931        'tls_required',
1932        'username',
1933    ]
1934
1935    def __init__(
1936        self,
1937        egress_filter=None,
1938        healthy=None,
1939        hostname=None,
1940        id=None,
1941        name=None,
1942        password=None,
1943        port=None,
1944        port_override=None,
1945        secret_store_id=None,
1946        tags=None,
1947        tls_required=None,
1948        username=None,
1949    ):
1950        self.egress_filter = egress_filter if egress_filter is not None else ''
1951        '''
1952         A filter applied to the routing logic to pin datasource to nodes.
1953        '''
1954        self.healthy = healthy if healthy is not None else False
1955        '''
1956         True if the datasource is reachable and the credentials are valid.
1957        '''
1958        self.hostname = hostname if hostname is not None else ''
1959        '''
1960
1961        '''
1962        self.id = id if id is not None else ''
1963        '''
1964         Unique identifier of the Resource.
1965        '''
1966        self.name = name if name is not None else ''
1967        '''
1968         Unique human-readable name of the Resource.
1969        '''
1970        self.password = password if password is not None else ''
1971        '''
1972
1973        '''
1974        self.port = port if port is not None else 0
1975        '''
1976
1977        '''
1978        self.port_override = port_override if port_override is not None else 0
1979        '''
1980
1981        '''
1982        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1983        '''
1984         ID of the secret store containing credentials for this resource, if any.
1985        '''
1986        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1987        '''
1988         Tags is a map of key, value pairs.
1989        '''
1990        self.tls_required = tls_required if tls_required is not None else False
1991        '''
1992
1993        '''
1994        self.username = username if username is not None else ''
1995        '''
1996
1997        '''
1998
1999    def __repr__(self):
2000        return '<sdm.AmazonMQAMQP091 ' + \
2001            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2002            'healthy: ' + repr(self.healthy) + ' ' +\
2003            'hostname: ' + repr(self.hostname) + ' ' +\
2004            'id: ' + repr(self.id) + ' ' +\
2005            'name: ' + repr(self.name) + ' ' +\
2006            'password: ' + repr(self.password) + ' ' +\
2007            'port: ' + repr(self.port) + ' ' +\
2008            'port_override: ' + repr(self.port_override) + ' ' +\
2009            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2010            'tags: ' + repr(self.tags) + ' ' +\
2011            'tls_required: ' + repr(self.tls_required) + ' ' +\
2012            'username: ' + repr(self.username) + ' ' +\
2013            '>'
2014
2015    def to_dict(self):
2016        return {
2017            'egress_filter': self.egress_filter,
2018            'healthy': self.healthy,
2019            'hostname': self.hostname,
2020            'id': self.id,
2021            'name': self.name,
2022            'password': self.password,
2023            'port': self.port,
2024            'port_override': self.port_override,
2025            'secret_store_id': self.secret_store_id,
2026            'tags': self.tags,
2027            'tls_required': self.tls_required,
2028            'username': self.username,
2029        }
2030
2031    @classmethod
2032    def from_dict(cls, d):
2033        return cls(
2034            egress_filter=d.get('egress_filter'),
2035            healthy=d.get('healthy'),
2036            hostname=d.get('hostname'),
2037            id=d.get('id'),
2038            name=d.get('name'),
2039            password=d.get('password'),
2040            port=d.get('port'),
2041            port_override=d.get('port_override'),
2042            secret_store_id=d.get('secret_store_id'),
2043            tags=d.get('tags'),
2044            tls_required=d.get('tls_required'),
2045            username=d.get('username'),
2046        )
#   AmazonMQAMQP091( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
1935    def __init__(
1936        self,
1937        egress_filter=None,
1938        healthy=None,
1939        hostname=None,
1940        id=None,
1941        name=None,
1942        password=None,
1943        port=None,
1944        port_override=None,
1945        secret_store_id=None,
1946        tags=None,
1947        tls_required=None,
1948        username=None,
1949    ):
1950        self.egress_filter = egress_filter if egress_filter is not None else ''
1951        '''
1952         A filter applied to the routing logic to pin datasource to nodes.
1953        '''
1954        self.healthy = healthy if healthy is not None else False
1955        '''
1956         True if the datasource is reachable and the credentials are valid.
1957        '''
1958        self.hostname = hostname if hostname is not None else ''
1959        '''
1960
1961        '''
1962        self.id = id if id is not None else ''
1963        '''
1964         Unique identifier of the Resource.
1965        '''
1966        self.name = name if name is not None else ''
1967        '''
1968         Unique human-readable name of the Resource.
1969        '''
1970        self.password = password if password is not None else ''
1971        '''
1972
1973        '''
1974        self.port = port if port is not None else 0
1975        '''
1976
1977        '''
1978        self.port_override = port_override if port_override is not None else 0
1979        '''
1980
1981        '''
1982        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1983        '''
1984         ID of the secret store containing credentials for this resource, if any.
1985        '''
1986        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1987        '''
1988         Tags is a map of key, value pairs.
1989        '''
1990        self.tls_required = tls_required if tls_required is not None else False
1991        '''
1992
1993        '''
1994        self.username = username if username is not None else ''
1995        '''
1996
1997        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
2015    def to_dict(self):
2016        return {
2017            'egress_filter': self.egress_filter,
2018            'healthy': self.healthy,
2019            'hostname': self.hostname,
2020            'id': self.id,
2021            'name': self.name,
2022            'password': self.password,
2023            'port': self.port,
2024            'port_override': self.port_override,
2025            'secret_store_id': self.secret_store_id,
2026            'tags': self.tags,
2027            'tls_required': self.tls_required,
2028            'username': self.username,
2029        }
#  
@classmethod
def from_dict(cls, d):
View Source
2031    @classmethod
2032    def from_dict(cls, d):
2033        return cls(
2034            egress_filter=d.get('egress_filter'),
2035            healthy=d.get('healthy'),
2036            hostname=d.get('hostname'),
2037            id=d.get('id'),
2038            name=d.get('name'),
2039            password=d.get('password'),
2040            port=d.get('port'),
2041            port_override=d.get('port_override'),
2042            secret_store_id=d.get('secret_store_id'),
2043            tags=d.get('tags'),
2044            tls_required=d.get('tls_required'),
2045            username=d.get('username'),
2046        )
#   class Athena:
View Source
2049class Athena:
2050    '''
2051
2052    '''
2053    __slots__ = [
2054        'access_key',
2055        'egress_filter',
2056        'healthy',
2057        'id',
2058        'name',
2059        'output',
2060        'port_override',
2061        'region',
2062        'role_arn',
2063        'role_external_id',
2064        'secret_access_key',
2065        'secret_store_id',
2066        'tags',
2067    ]
2068
2069    def __init__(
2070        self,
2071        access_key=None,
2072        egress_filter=None,
2073        healthy=None,
2074        id=None,
2075        name=None,
2076        output=None,
2077        port_override=None,
2078        region=None,
2079        role_arn=None,
2080        role_external_id=None,
2081        secret_access_key=None,
2082        secret_store_id=None,
2083        tags=None,
2084    ):
2085        self.access_key = access_key if access_key is not None else ''
2086        '''
2087
2088        '''
2089        self.egress_filter = egress_filter if egress_filter is not None else ''
2090        '''
2091         A filter applied to the routing logic to pin datasource to nodes.
2092        '''
2093        self.healthy = healthy if healthy is not None else False
2094        '''
2095         True if the datasource is reachable and the credentials are valid.
2096        '''
2097        self.id = id if id is not None else ''
2098        '''
2099         Unique identifier of the Resource.
2100        '''
2101        self.name = name if name is not None else ''
2102        '''
2103         Unique human-readable name of the Resource.
2104        '''
2105        self.output = output if output is not None else ''
2106        '''
2107
2108        '''
2109        self.port_override = port_override if port_override is not None else 0
2110        '''
2111
2112        '''
2113        self.region = region if region is not None else ''
2114        '''
2115
2116        '''
2117        self.role_arn = role_arn if role_arn is not None else ''
2118        '''
2119
2120        '''
2121        self.role_external_id = role_external_id if role_external_id is not None else ''
2122        '''
2123
2124        '''
2125        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2126        '''
2127
2128        '''
2129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2130        '''
2131         ID of the secret store containing credentials for this resource, if any.
2132        '''
2133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2134        '''
2135         Tags is a map of key, value pairs.
2136        '''
2137
2138    def __repr__(self):
2139        return '<sdm.Athena ' + \
2140            'access_key: ' + repr(self.access_key) + ' ' +\
2141            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2142            'healthy: ' + repr(self.healthy) + ' ' +\
2143            'id: ' + repr(self.id) + ' ' +\
2144            'name: ' + repr(self.name) + ' ' +\
2145            'output: ' + repr(self.output) + ' ' +\
2146            'port_override: ' + repr(self.port_override) + ' ' +\
2147            'region: ' + repr(self.region) + ' ' +\
2148            'role_arn: ' + repr(self.role_arn) + ' ' +\
2149            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2150            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2151            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2152            'tags: ' + repr(self.tags) + ' ' +\
2153            '>'
2154
2155    def to_dict(self):
2156        return {
2157            'access_key': self.access_key,
2158            'egress_filter': self.egress_filter,
2159            'healthy': self.healthy,
2160            'id': self.id,
2161            'name': self.name,
2162            'output': self.output,
2163            'port_override': self.port_override,
2164            'region': self.region,
2165            'role_arn': self.role_arn,
2166            'role_external_id': self.role_external_id,
2167            'secret_access_key': self.secret_access_key,
2168            'secret_store_id': self.secret_store_id,
2169            'tags': self.tags,
2170        }
2171
2172    @classmethod
2173    def from_dict(cls, d):
2174        return cls(
2175            access_key=d.get('access_key'),
2176            egress_filter=d.get('egress_filter'),
2177            healthy=d.get('healthy'),
2178            id=d.get('id'),
2179            name=d.get('name'),
2180            output=d.get('output'),
2181            port_override=d.get('port_override'),
2182            region=d.get('region'),
2183            role_arn=d.get('role_arn'),
2184            role_external_id=d.get('role_external_id'),
2185            secret_access_key=d.get('secret_access_key'),
2186            secret_store_id=d.get('secret_store_id'),
2187            tags=d.get('tags'),
2188        )
#   Athena( access_key=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
2069    def __init__(
2070        self,
2071        access_key=None,
2072        egress_filter=None,
2073        healthy=None,
2074        id=None,
2075        name=None,
2076        output=None,
2077        port_override=None,
2078        region=None,
2079        role_arn=None,
2080        role_external_id=None,
2081        secret_access_key=None,
2082        secret_store_id=None,
2083        tags=None,
2084    ):
2085        self.access_key = access_key if access_key is not None else ''
2086        '''
2087
2088        '''
2089        self.egress_filter = egress_filter if egress_filter is not None else ''
2090        '''
2091         A filter applied to the routing logic to pin datasource to nodes.
2092        '''
2093        self.healthy = healthy if healthy is not None else False
2094        '''
2095         True if the datasource is reachable and the credentials are valid.
2096        '''
2097        self.id = id if id is not None else ''
2098        '''
2099         Unique identifier of the Resource.
2100        '''
2101        self.name = name if name is not None else ''
2102        '''
2103         Unique human-readable name of the Resource.
2104        '''
2105        self.output = output if output is not None else ''
2106        '''
2107
2108        '''
2109        self.port_override = port_override if port_override is not None else 0
2110        '''
2111
2112        '''
2113        self.region = region if region is not None else ''
2114        '''
2115
2116        '''
2117        self.role_arn = role_arn if role_arn is not None else ''
2118        '''
2119
2120        '''
2121        self.role_external_id = role_external_id if role_external_id is not None else ''
2122        '''
2123
2124        '''
2125        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2126        '''
2127
2128        '''
2129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2130        '''
2131         ID of the secret store containing credentials for this resource, if any.
2132        '''
2133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2134        '''
2135         Tags is a map of key, value pairs.
2136        '''
#   access_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   output
#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
2155    def to_dict(self):
2156        return {
2157            'access_key': self.access_key,
2158            'egress_filter': self.egress_filter,
2159            'healthy': self.healthy,
2160            'id': self.id,
2161            'name': self.name,
2162            'output': self.output,
2163            'port_override': self.port_override,
2164            'region': self.region,
2165            'role_arn': self.role_arn,
2166            'role_external_id': self.role_external_id,
2167            'secret_access_key': self.secret_access_key,
2168            'secret_store_id': self.secret_store_id,
2169            'tags': self.tags,
2170        }
#  
@classmethod
def from_dict(cls, d):
View Source
2172    @classmethod
2173    def from_dict(cls, d):
2174        return cls(
2175            access_key=d.get('access_key'),
2176            egress_filter=d.get('egress_filter'),
2177            healthy=d.get('healthy'),
2178            id=d.get('id'),
2179            name=d.get('name'),
2180            output=d.get('output'),
2181            port_override=d.get('port_override'),
2182            region=d.get('region'),
2183            role_arn=d.get('role_arn'),
2184            role_external_id=d.get('role_external_id'),
2185            secret_access_key=d.get('secret_access_key'),
2186            secret_store_id=d.get('secret_store_id'),
2187            tags=d.get('tags'),
2188        )
#   class AuroraMysql:
View Source
2191class AuroraMysql:
2192    '''
2193
2194    '''
2195    __slots__ = [
2196        'database',
2197        'egress_filter',
2198        'healthy',
2199        'hostname',
2200        'id',
2201        'name',
2202        'password',
2203        'port',
2204        'port_override',
2205        'secret_store_id',
2206        'tags',
2207        'username',
2208    ]
2209
2210    def __init__(
2211        self,
2212        database=None,
2213        egress_filter=None,
2214        healthy=None,
2215        hostname=None,
2216        id=None,
2217        name=None,
2218        password=None,
2219        port=None,
2220        port_override=None,
2221        secret_store_id=None,
2222        tags=None,
2223        username=None,
2224    ):
2225        self.database = database if database is not None else ''
2226        '''
2227
2228        '''
2229        self.egress_filter = egress_filter if egress_filter is not None else ''
2230        '''
2231         A filter applied to the routing logic to pin datasource to nodes.
2232        '''
2233        self.healthy = healthy if healthy is not None else False
2234        '''
2235         True if the datasource is reachable and the credentials are valid.
2236        '''
2237        self.hostname = hostname if hostname is not None else ''
2238        '''
2239
2240        '''
2241        self.id = id if id is not None else ''
2242        '''
2243         Unique identifier of the Resource.
2244        '''
2245        self.name = name if name is not None else ''
2246        '''
2247         Unique human-readable name of the Resource.
2248        '''
2249        self.password = password if password is not None else ''
2250        '''
2251
2252        '''
2253        self.port = port if port is not None else 0
2254        '''
2255
2256        '''
2257        self.port_override = port_override if port_override is not None else 0
2258        '''
2259
2260        '''
2261        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2262        '''
2263         ID of the secret store containing credentials for this resource, if any.
2264        '''
2265        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2266        '''
2267         Tags is a map of key, value pairs.
2268        '''
2269        self.username = username if username is not None else ''
2270        '''
2271
2272        '''
2273
2274    def __repr__(self):
2275        return '<sdm.AuroraMysql ' + \
2276            'database: ' + repr(self.database) + ' ' +\
2277            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2278            'healthy: ' + repr(self.healthy) + ' ' +\
2279            'hostname: ' + repr(self.hostname) + ' ' +\
2280            'id: ' + repr(self.id) + ' ' +\
2281            'name: ' + repr(self.name) + ' ' +\
2282            'password: ' + repr(self.password) + ' ' +\
2283            'port: ' + repr(self.port) + ' ' +\
2284            'port_override: ' + repr(self.port_override) + ' ' +\
2285            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2286            'tags: ' + repr(self.tags) + ' ' +\
2287            'username: ' + repr(self.username) + ' ' +\
2288            '>'
2289
2290    def to_dict(self):
2291        return {
2292            'database': self.database,
2293            'egress_filter': self.egress_filter,
2294            'healthy': self.healthy,
2295            'hostname': self.hostname,
2296            'id': self.id,
2297            'name': self.name,
2298            'password': self.password,
2299            'port': self.port,
2300            'port_override': self.port_override,
2301            'secret_store_id': self.secret_store_id,
2302            'tags': self.tags,
2303            'username': self.username,
2304        }
2305
2306    @classmethod
2307    def from_dict(cls, d):
2308        return cls(
2309            database=d.get('database'),
2310            egress_filter=d.get('egress_filter'),
2311            healthy=d.get('healthy'),
2312            hostname=d.get('hostname'),
2313            id=d.get('id'),
2314            name=d.get('name'),
2315            password=d.get('password'),
2316            port=d.get('port'),
2317            port_override=d.get('port_override'),
2318            secret_store_id=d.get('secret_store_id'),
2319            tags=d.get('tags'),
2320            username=d.get('username'),
2321        )
#   AuroraMysql( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
2210    def __init__(
2211        self,
2212        database=None,
2213        egress_filter=None,
2214        healthy=None,
2215        hostname=None,
2216        id=None,
2217        name=None,
2218        password=None,
2219        port=None,
2220        port_override=None,
2221        secret_store_id=None,
2222        tags=None,
2223        username=None,
2224    ):
2225        self.database = database if database is not None else ''
2226        '''
2227
2228        '''
2229        self.egress_filter = egress_filter if egress_filter is not None else ''
2230        '''
2231         A filter applied to the routing logic to pin datasource to nodes.
2232        '''
2233        self.healthy = healthy if healthy is not None else False
2234        '''
2235         True if the datasource is reachable and the credentials are valid.
2236        '''
2237        self.hostname = hostname if hostname is not None else ''
2238        '''
2239
2240        '''
2241        self.id = id if id is not None else ''
2242        '''
2243         Unique identifier of the Resource.
2244        '''
2245        self.name = name if name is not None else ''
2246        '''
2247         Unique human-readable name of the Resource.
2248        '''
2249        self.password = password if password is not None else ''
2250        '''
2251
2252        '''
2253        self.port = port if port is not None else 0
2254        '''
2255
2256        '''
2257        self.port_override = port_override if port_override is not None else 0
2258        '''
2259
2260        '''
2261        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2262        '''
2263         ID of the secret store containing credentials for this resource, if any.
2264        '''
2265        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2266        '''
2267         Tags is a map of key, value pairs.
2268        '''
2269        self.username = username if username is not None else ''
2270        '''
2271
2272        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
2290    def to_dict(self):
2291        return {
2292            'database': self.database,
2293            'egress_filter': self.egress_filter,
2294            'healthy': self.healthy,
2295            'hostname': self.hostname,
2296            'id': self.id,
2297            'name': self.name,
2298            'password': self.password,
2299            'port': self.port,
2300            'port_override': self.port_override,
2301            'secret_store_id': self.secret_store_id,
2302            'tags': self.tags,
2303            'username': self.username,
2304        }
#  
@classmethod
def from_dict(cls, d):
View Source
2306    @classmethod
2307    def from_dict(cls, d):
2308        return cls(
2309            database=d.get('database'),
2310            egress_filter=d.get('egress_filter'),
2311            healthy=d.get('healthy'),
2312            hostname=d.get('hostname'),
2313            id=d.get('id'),
2314            name=d.get('name'),
2315            password=d.get('password'),
2316            port=d.get('port'),
2317            port_override=d.get('port_override'),
2318            secret_store_id=d.get('secret_store_id'),
2319            tags=d.get('tags'),
2320            username=d.get('username'),
2321        )
#   class AuroraPostgres:
View Source
2324class AuroraPostgres:
2325    '''
2326
2327    '''
2328    __slots__ = [
2329        'database',
2330        'egress_filter',
2331        'healthy',
2332        'hostname',
2333        'id',
2334        'name',
2335        'override_database',
2336        'password',
2337        'port',
2338        'port_override',
2339        'secret_store_id',
2340        'tags',
2341        'username',
2342    ]
2343
2344    def __init__(
2345        self,
2346        database=None,
2347        egress_filter=None,
2348        healthy=None,
2349        hostname=None,
2350        id=None,
2351        name=None,
2352        override_database=None,
2353        password=None,
2354        port=None,
2355        port_override=None,
2356        secret_store_id=None,
2357        tags=None,
2358        username=None,
2359    ):
2360        self.database = database if database is not None else ''
2361        '''
2362
2363        '''
2364        self.egress_filter = egress_filter if egress_filter is not None else ''
2365        '''
2366         A filter applied to the routing logic to pin datasource to nodes.
2367        '''
2368        self.healthy = healthy if healthy is not None else False
2369        '''
2370         True if the datasource is reachable and the credentials are valid.
2371        '''
2372        self.hostname = hostname if hostname is not None else ''
2373        '''
2374
2375        '''
2376        self.id = id if id is not None else ''
2377        '''
2378         Unique identifier of the Resource.
2379        '''
2380        self.name = name if name is not None else ''
2381        '''
2382         Unique human-readable name of the Resource.
2383        '''
2384        self.override_database = override_database if override_database is not None else False
2385        '''
2386
2387        '''
2388        self.password = password if password is not None else ''
2389        '''
2390
2391        '''
2392        self.port = port if port is not None else 0
2393        '''
2394
2395        '''
2396        self.port_override = port_override if port_override is not None else 0
2397        '''
2398
2399        '''
2400        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2401        '''
2402         ID of the secret store containing credentials for this resource, if any.
2403        '''
2404        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2405        '''
2406         Tags is a map of key, value pairs.
2407        '''
2408        self.username = username if username is not None else ''
2409        '''
2410
2411        '''
2412
2413    def __repr__(self):
2414        return '<sdm.AuroraPostgres ' + \
2415            'database: ' + repr(self.database) + ' ' +\
2416            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2417            'healthy: ' + repr(self.healthy) + ' ' +\
2418            'hostname: ' + repr(self.hostname) + ' ' +\
2419            'id: ' + repr(self.id) + ' ' +\
2420            'name: ' + repr(self.name) + ' ' +\
2421            'override_database: ' + repr(self.override_database) + ' ' +\
2422            'password: ' + repr(self.password) + ' ' +\
2423            'port: ' + repr(self.port) + ' ' +\
2424            'port_override: ' + repr(self.port_override) + ' ' +\
2425            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2426            'tags: ' + repr(self.tags) + ' ' +\
2427            'username: ' + repr(self.username) + ' ' +\
2428            '>'
2429
2430    def to_dict(self):
2431        return {
2432            'database': self.database,
2433            'egress_filter': self.egress_filter,
2434            'healthy': self.healthy,
2435            'hostname': self.hostname,
2436            'id': self.id,
2437            'name': self.name,
2438            'override_database': self.override_database,
2439            'password': self.password,
2440            'port': self.port,
2441            'port_override': self.port_override,
2442            'secret_store_id': self.secret_store_id,
2443            'tags': self.tags,
2444            'username': self.username,
2445        }
2446
2447    @classmethod
2448    def from_dict(cls, d):
2449        return cls(
2450            database=d.get('database'),
2451            egress_filter=d.get('egress_filter'),
2452            healthy=d.get('healthy'),
2453            hostname=d.get('hostname'),
2454            id=d.get('id'),
2455            name=d.get('name'),
2456            override_database=d.get('override_database'),
2457            password=d.get('password'),
2458            port=d.get('port'),
2459            port_override=d.get('port_override'),
2460            secret_store_id=d.get('secret_store_id'),
2461            tags=d.get('tags'),
2462            username=d.get('username'),
2463        )
#   AuroraPostgres( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
2344    def __init__(
2345        self,
2346        database=None,
2347        egress_filter=None,
2348        healthy=None,
2349        hostname=None,
2350        id=None,
2351        name=None,
2352        override_database=None,
2353        password=None,
2354        port=None,
2355        port_override=None,
2356        secret_store_id=None,
2357        tags=None,
2358        username=None,
2359    ):
2360        self.database = database if database is not None else ''
2361        '''
2362
2363        '''
2364        self.egress_filter = egress_filter if egress_filter is not None else ''
2365        '''
2366         A filter applied to the routing logic to pin datasource to nodes.
2367        '''
2368        self.healthy = healthy if healthy is not None else False
2369        '''
2370         True if the datasource is reachable and the credentials are valid.
2371        '''
2372        self.hostname = hostname if hostname is not None else ''
2373        '''
2374
2375        '''
2376        self.id = id if id is not None else ''
2377        '''
2378         Unique identifier of the Resource.
2379        '''
2380        self.name = name if name is not None else ''
2381        '''
2382         Unique human-readable name of the Resource.
2383        '''
2384        self.override_database = override_database if override_database is not None else False
2385        '''
2386
2387        '''
2388        self.password = password if password is not None else ''
2389        '''
2390
2391        '''
2392        self.port = port if port is not None else 0
2393        '''
2394
2395        '''
2396        self.port_override = port_override if port_override is not None else 0
2397        '''
2398
2399        '''
2400        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2401        '''
2402         ID of the secret store containing credentials for this resource, if any.
2403        '''
2404        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2405        '''
2406         Tags is a map of key, value pairs.
2407        '''
2408        self.username = username if username is not None else ''
2409        '''
2410
2411        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
2430    def to_dict(self):
2431        return {
2432            'database': self.database,
2433            'egress_filter': self.egress_filter,
2434            'healthy': self.healthy,
2435            'hostname': self.hostname,
2436            'id': self.id,
2437            'name': self.name,
2438            'override_database': self.override_database,
2439            'password': self.password,
2440            'port': self.port,
2441            'port_override': self.port_override,
2442            'secret_store_id': self.secret_store_id,
2443            'tags': self.tags,
2444            'username': self.username,
2445        }
#  
@classmethod
def from_dict(cls, d):
View Source
2447    @classmethod
2448    def from_dict(cls, d):
2449        return cls(
2450            database=d.get('database'),
2451            egress_filter=d.get('egress_filter'),
2452            healthy=d.get('healthy'),
2453            hostname=d.get('hostname'),
2454            id=d.get('id'),
2455            name=d.get('name'),
2456            override_database=d.get('override_database'),
2457            password=d.get('password'),
2458            port=d.get('port'),
2459            port_override=d.get('port_override'),
2460            secret_store_id=d.get('secret_store_id'),
2461            tags=d.get('tags'),
2462            username=d.get('username'),
2463        )
#   class Azure:
View Source
2466class Azure:
2467    '''
2468
2469    '''
2470    __slots__ = [
2471        'app_id',
2472        'egress_filter',
2473        'healthy',
2474        'id',
2475        'name',
2476        'password',
2477        'secret_store_id',
2478        'tags',
2479        'tenant_id',
2480    ]
2481
2482    def __init__(
2483        self,
2484        app_id=None,
2485        egress_filter=None,
2486        healthy=None,
2487        id=None,
2488        name=None,
2489        password=None,
2490        secret_store_id=None,
2491        tags=None,
2492        tenant_id=None,
2493    ):
2494        self.app_id = app_id if app_id is not None else ''
2495        '''
2496
2497        '''
2498        self.egress_filter = egress_filter if egress_filter is not None else ''
2499        '''
2500         A filter applied to the routing logic to pin datasource to nodes.
2501        '''
2502        self.healthy = healthy if healthy is not None else False
2503        '''
2504         True if the datasource is reachable and the credentials are valid.
2505        '''
2506        self.id = id if id is not None else ''
2507        '''
2508         Unique identifier of the Resource.
2509        '''
2510        self.name = name if name is not None else ''
2511        '''
2512         Unique human-readable name of the Resource.
2513        '''
2514        self.password = password if password is not None else ''
2515        '''
2516
2517        '''
2518        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2519        '''
2520         ID of the secret store containing credentials for this resource, if any.
2521        '''
2522        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2523        '''
2524         Tags is a map of key, value pairs.
2525        '''
2526        self.tenant_id = tenant_id if tenant_id is not None else ''
2527        '''
2528
2529        '''
2530
2531    def __repr__(self):
2532        return '<sdm.Azure ' + \
2533            'app_id: ' + repr(self.app_id) + ' ' +\
2534            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2535            'healthy: ' + repr(self.healthy) + ' ' +\
2536            'id: ' + repr(self.id) + ' ' +\
2537            'name: ' + repr(self.name) + ' ' +\
2538            'password: ' + repr(self.password) + ' ' +\
2539            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2540            'tags: ' + repr(self.tags) + ' ' +\
2541            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2542            '>'
2543
2544    def to_dict(self):
2545        return {
2546            'app_id': self.app_id,
2547            'egress_filter': self.egress_filter,
2548            'healthy': self.healthy,
2549            'id': self.id,
2550            'name': self.name,
2551            'password': self.password,
2552            'secret_store_id': self.secret_store_id,
2553            'tags': self.tags,
2554            'tenant_id': self.tenant_id,
2555        }
2556
2557    @classmethod
2558    def from_dict(cls, d):
2559        return cls(
2560            app_id=d.get('app_id'),
2561            egress_filter=d.get('egress_filter'),
2562            healthy=d.get('healthy'),
2563            id=d.get('id'),
2564            name=d.get('name'),
2565            password=d.get('password'),
2566            secret_store_id=d.get('secret_store_id'),
2567            tags=d.get('tags'),
2568            tenant_id=d.get('tenant_id'),
2569        )
#   Azure( app_id=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None )
View Source
2482    def __init__(
2483        self,
2484        app_id=None,
2485        egress_filter=None,
2486        healthy=None,
2487        id=None,
2488        name=None,
2489        password=None,
2490        secret_store_id=None,
2491        tags=None,
2492        tenant_id=None,
2493    ):
2494        self.app_id = app_id if app_id is not None else ''
2495        '''
2496
2497        '''
2498        self.egress_filter = egress_filter if egress_filter is not None else ''
2499        '''
2500         A filter applied to the routing logic to pin datasource to nodes.
2501        '''
2502        self.healthy = healthy if healthy is not None else False
2503        '''
2504         True if the datasource is reachable and the credentials are valid.
2505        '''
2506        self.id = id if id is not None else ''
2507        '''
2508         Unique identifier of the Resource.
2509        '''
2510        self.name = name if name is not None else ''
2511        '''
2512         Unique human-readable name of the Resource.
2513        '''
2514        self.password = password if password is not None else ''
2515        '''
2516
2517        '''
2518        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2519        '''
2520         ID of the secret store containing credentials for this resource, if any.
2521        '''
2522        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2523        '''
2524         Tags is a map of key, value pairs.
2525        '''
2526        self.tenant_id = tenant_id if tenant_id is not None else ''
2527        '''
2528
2529        '''
#   app_id
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tenant_id
#   def to_dict(self):
View Source
2544    def to_dict(self):
2545        return {
2546            'app_id': self.app_id,
2547            'egress_filter': self.egress_filter,
2548            'healthy': self.healthy,
2549            'id': self.id,
2550            'name': self.name,
2551            'password': self.password,
2552            'secret_store_id': self.secret_store_id,
2553            'tags': self.tags,
2554            'tenant_id': self.tenant_id,
2555        }
#  
@classmethod
def from_dict(cls, d):
View Source
2557    @classmethod
2558    def from_dict(cls, d):
2559        return cls(
2560            app_id=d.get('app_id'),
2561            egress_filter=d.get('egress_filter'),
2562            healthy=d.get('healthy'),
2563            id=d.get('id'),
2564            name=d.get('name'),
2565            password=d.get('password'),
2566            secret_store_id=d.get('secret_store_id'),
2567            tags=d.get('tags'),
2568            tenant_id=d.get('tenant_id'),
2569        )
#   class AzureCertificate:
View Source
2572class AzureCertificate:
2573    '''
2574
2575    '''
2576    __slots__ = [
2577        'app_id',
2578        'client_certificate',
2579        'egress_filter',
2580        'healthy',
2581        'id',
2582        'name',
2583        'secret_store_id',
2584        'tags',
2585        'tenant_id',
2586    ]
2587
2588    def __init__(
2589        self,
2590        app_id=None,
2591        client_certificate=None,
2592        egress_filter=None,
2593        healthy=None,
2594        id=None,
2595        name=None,
2596        secret_store_id=None,
2597        tags=None,
2598        tenant_id=None,
2599    ):
2600        self.app_id = app_id if app_id is not None else ''
2601        '''
2602
2603        '''
2604        self.client_certificate = client_certificate if client_certificate is not None else ''
2605        '''
2606
2607        '''
2608        self.egress_filter = egress_filter if egress_filter is not None else ''
2609        '''
2610         A filter applied to the routing logic to pin datasource to nodes.
2611        '''
2612        self.healthy = healthy if healthy is not None else False
2613        '''
2614         True if the datasource is reachable and the credentials are valid.
2615        '''
2616        self.id = id if id is not None else ''
2617        '''
2618         Unique identifier of the Resource.
2619        '''
2620        self.name = name if name is not None else ''
2621        '''
2622         Unique human-readable name of the Resource.
2623        '''
2624        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2625        '''
2626         ID of the secret store containing credentials for this resource, if any.
2627        '''
2628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2629        '''
2630         Tags is a map of key, value pairs.
2631        '''
2632        self.tenant_id = tenant_id if tenant_id is not None else ''
2633        '''
2634
2635        '''
2636
2637    def __repr__(self):
2638        return '<sdm.AzureCertificate ' + \
2639            'app_id: ' + repr(self.app_id) + ' ' +\
2640            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2641            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2642            'healthy: ' + repr(self.healthy) + ' ' +\
2643            'id: ' + repr(self.id) + ' ' +\
2644            'name: ' + repr(self.name) + ' ' +\
2645            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2646            'tags: ' + repr(self.tags) + ' ' +\
2647            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2648            '>'
2649
2650    def to_dict(self):
2651        return {
2652            'app_id': self.app_id,
2653            'client_certificate': self.client_certificate,
2654            'egress_filter': self.egress_filter,
2655            'healthy': self.healthy,
2656            'id': self.id,
2657            'name': self.name,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'tenant_id': self.tenant_id,
2661        }
2662
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            app_id=d.get('app_id'),
2667            client_certificate=d.get('client_certificate'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            id=d.get('id'),
2671            name=d.get('name'),
2672            secret_store_id=d.get('secret_store_id'),
2673            tags=d.get('tags'),
2674            tenant_id=d.get('tenant_id'),
2675        )
#   AzureCertificate( app_id=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None )
View Source
2588    def __init__(
2589        self,
2590        app_id=None,
2591        client_certificate=None,
2592        egress_filter=None,
2593        healthy=None,
2594        id=None,
2595        name=None,
2596        secret_store_id=None,
2597        tags=None,
2598        tenant_id=None,
2599    ):
2600        self.app_id = app_id if app_id is not None else ''
2601        '''
2602
2603        '''
2604        self.client_certificate = client_certificate if client_certificate is not None else ''
2605        '''
2606
2607        '''
2608        self.egress_filter = egress_filter if egress_filter is not None else ''
2609        '''
2610         A filter applied to the routing logic to pin datasource to nodes.
2611        '''
2612        self.healthy = healthy if healthy is not None else False
2613        '''
2614         True if the datasource is reachable and the credentials are valid.
2615        '''
2616        self.id = id if id is not None else ''
2617        '''
2618         Unique identifier of the Resource.
2619        '''
2620        self.name = name if name is not None else ''
2621        '''
2622         Unique human-readable name of the Resource.
2623        '''
2624        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2625        '''
2626         ID of the secret store containing credentials for this resource, if any.
2627        '''
2628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2629        '''
2630         Tags is a map of key, value pairs.
2631        '''
2632        self.tenant_id = tenant_id if tenant_id is not None else ''
2633        '''
2634
2635        '''
#   app_id
#   client_certificate
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tenant_id
#   def to_dict(self):
View Source
2650    def to_dict(self):
2651        return {
2652            'app_id': self.app_id,
2653            'client_certificate': self.client_certificate,
2654            'egress_filter': self.egress_filter,
2655            'healthy': self.healthy,
2656            'id': self.id,
2657            'name': self.name,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'tenant_id': self.tenant_id,
2661        }
#  
@classmethod
def from_dict(cls, d):
View Source
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            app_id=d.get('app_id'),
2667            client_certificate=d.get('client_certificate'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            id=d.get('id'),
2671            name=d.get('name'),
2672            secret_store_id=d.get('secret_store_id'),
2673            tags=d.get('tags'),
2674            tenant_id=d.get('tenant_id'),
2675        )
#   class AzurePostgres:
View Source
2678class AzurePostgres:
2679    '''
2680
2681    '''
2682    __slots__ = [
2683        'database',
2684        'egress_filter',
2685        'healthy',
2686        'hostname',
2687        'id',
2688        'name',
2689        'override_database',
2690        'password',
2691        'port',
2692        'port_override',
2693        'secret_store_id',
2694        'tags',
2695        'username',
2696    ]
2697
2698    def __init__(
2699        self,
2700        database=None,
2701        egress_filter=None,
2702        healthy=None,
2703        hostname=None,
2704        id=None,
2705        name=None,
2706        override_database=None,
2707        password=None,
2708        port=None,
2709        port_override=None,
2710        secret_store_id=None,
2711        tags=None,
2712        username=None,
2713    ):
2714        self.database = database if database is not None else ''
2715        '''
2716
2717        '''
2718        self.egress_filter = egress_filter if egress_filter is not None else ''
2719        '''
2720         A filter applied to the routing logic to pin datasource to nodes.
2721        '''
2722        self.healthy = healthy if healthy is not None else False
2723        '''
2724         True if the datasource is reachable and the credentials are valid.
2725        '''
2726        self.hostname = hostname if hostname is not None else ''
2727        '''
2728
2729        '''
2730        self.id = id if id is not None else ''
2731        '''
2732         Unique identifier of the Resource.
2733        '''
2734        self.name = name if name is not None else ''
2735        '''
2736         Unique human-readable name of the Resource.
2737        '''
2738        self.override_database = override_database if override_database is not None else False
2739        '''
2740
2741        '''
2742        self.password = password if password is not None else ''
2743        '''
2744
2745        '''
2746        self.port = port if port is not None else 0
2747        '''
2748
2749        '''
2750        self.port_override = port_override if port_override is not None else 0
2751        '''
2752
2753        '''
2754        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2755        '''
2756         ID of the secret store containing credentials for this resource, if any.
2757        '''
2758        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2759        '''
2760         Tags is a map of key, value pairs.
2761        '''
2762        self.username = username if username is not None else ''
2763        '''
2764
2765        '''
2766
2767    def __repr__(self):
2768        return '<sdm.AzurePostgres ' + \
2769            'database: ' + repr(self.database) + ' ' +\
2770            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2771            'healthy: ' + repr(self.healthy) + ' ' +\
2772            'hostname: ' + repr(self.hostname) + ' ' +\
2773            'id: ' + repr(self.id) + ' ' +\
2774            'name: ' + repr(self.name) + ' ' +\
2775            'override_database: ' + repr(self.override_database) + ' ' +\
2776            'password: ' + repr(self.password) + ' ' +\
2777            'port: ' + repr(self.port) + ' ' +\
2778            'port_override: ' + repr(self.port_override) + ' ' +\
2779            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2780            'tags: ' + repr(self.tags) + ' ' +\
2781            'username: ' + repr(self.username) + ' ' +\
2782            '>'
2783
2784    def to_dict(self):
2785        return {
2786            'database': self.database,
2787            'egress_filter': self.egress_filter,
2788            'healthy': self.healthy,
2789            'hostname': self.hostname,
2790            'id': self.id,
2791            'name': self.name,
2792            'override_database': self.override_database,
2793            'password': self.password,
2794            'port': self.port,
2795            'port_override': self.port_override,
2796            'secret_store_id': self.secret_store_id,
2797            'tags': self.tags,
2798            'username': self.username,
2799        }
2800
2801    @classmethod
2802    def from_dict(cls, d):
2803        return cls(
2804            database=d.get('database'),
2805            egress_filter=d.get('egress_filter'),
2806            healthy=d.get('healthy'),
2807            hostname=d.get('hostname'),
2808            id=d.get('id'),
2809            name=d.get('name'),
2810            override_database=d.get('override_database'),
2811            password=d.get('password'),
2812            port=d.get('port'),
2813            port_override=d.get('port_override'),
2814            secret_store_id=d.get('secret_store_id'),
2815            tags=d.get('tags'),
2816            username=d.get('username'),
2817        )
#   AzurePostgres( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
2698    def __init__(
2699        self,
2700        database=None,
2701        egress_filter=None,
2702        healthy=None,
2703        hostname=None,
2704        id=None,
2705        name=None,
2706        override_database=None,
2707        password=None,
2708        port=None,
2709        port_override=None,
2710        secret_store_id=None,
2711        tags=None,
2712        username=None,
2713    ):
2714        self.database = database if database is not None else ''
2715        '''
2716
2717        '''
2718        self.egress_filter = egress_filter if egress_filter is not None else ''
2719        '''
2720         A filter applied to the routing logic to pin datasource to nodes.
2721        '''
2722        self.healthy = healthy if healthy is not None else False
2723        '''
2724         True if the datasource is reachable and the credentials are valid.
2725        '''
2726        self.hostname = hostname if hostname is not None else ''
2727        '''
2728
2729        '''
2730        self.id = id if id is not None else ''
2731        '''
2732         Unique identifier of the Resource.
2733        '''
2734        self.name = name if name is not None else ''
2735        '''
2736         Unique human-readable name of the Resource.
2737        '''
2738        self.override_database = override_database if override_database is not None else False
2739        '''
2740
2741        '''
2742        self.password = password if password is not None else ''
2743        '''
2744
2745        '''
2746        self.port = port if port is not None else 0
2747        '''
2748
2749        '''
2750        self.port_override = port_override if port_override is not None else 0
2751        '''
2752
2753        '''
2754        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2755        '''
2756         ID of the secret store containing credentials for this resource, if any.
2757        '''
2758        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2759        '''
2760         Tags is a map of key, value pairs.
2761        '''
2762        self.username = username if username is not None else ''
2763        '''
2764
2765        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
2784    def to_dict(self):
2785        return {
2786            'database': self.database,
2787            'egress_filter': self.egress_filter,
2788            'healthy': self.healthy,
2789            'hostname': self.hostname,
2790            'id': self.id,
2791            'name': self.name,
2792            'override_database': self.override_database,
2793            'password': self.password,
2794            'port': self.port,
2795            'port_override': self.port_override,
2796            'secret_store_id': self.secret_store_id,
2797            'tags': self.tags,
2798            'username': self.username,
2799        }
#  
@classmethod
def from_dict(cls, d):
View Source
2801    @classmethod
2802    def from_dict(cls, d):
2803        return cls(
2804            database=d.get('database'),
2805            egress_filter=d.get('egress_filter'),
2806            healthy=d.get('healthy'),
2807            hostname=d.get('hostname'),
2808            id=d.get('id'),
2809            name=d.get('name'),
2810            override_database=d.get('override_database'),
2811            password=d.get('password'),
2812            port=d.get('port'),
2813            port_override=d.get('port_override'),
2814            secret_store_id=d.get('secret_store_id'),
2815            tags=d.get('tags'),
2816            username=d.get('username'),
2817        )
#   class AzureStore:
View Source
2820class AzureStore:
2821    '''
2822
2823    '''
2824    __slots__ = [
2825        'id',
2826        'name',
2827        'tags',
2828        'vault_uri',
2829    ]
2830
2831    def __init__(
2832        self,
2833        id=None,
2834        name=None,
2835        tags=None,
2836        vault_uri=None,
2837    ):
2838        self.id = id if id is not None else ''
2839        '''
2840         Unique identifier of the SecretStore.
2841        '''
2842        self.name = name if name is not None else ''
2843        '''
2844         Unique human-readable name of the SecretStore.
2845        '''
2846        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2847        '''
2848         Tags is a map of key, value pairs.
2849        '''
2850        self.vault_uri = vault_uri if vault_uri is not None else ''
2851        '''
2852
2853        '''
2854
2855    def __repr__(self):
2856        return '<sdm.AzureStore ' + \
2857            'id: ' + repr(self.id) + ' ' +\
2858            'name: ' + repr(self.name) + ' ' +\
2859            'tags: ' + repr(self.tags) + ' ' +\
2860            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
2861            '>'
2862
2863    def to_dict(self):
2864        return {
2865            'id': self.id,
2866            'name': self.name,
2867            'tags': self.tags,
2868            'vault_uri': self.vault_uri,
2869        }
2870
2871    @classmethod
2872    def from_dict(cls, d):
2873        return cls(
2874            id=d.get('id'),
2875            name=d.get('name'),
2876            tags=d.get('tags'),
2877            vault_uri=d.get('vault_uri'),
2878        )
#   AzureStore(id=None, name=None, tags=None, vault_uri=None)
View Source
2831    def __init__(
2832        self,
2833        id=None,
2834        name=None,
2835        tags=None,
2836        vault_uri=None,
2837    ):
2838        self.id = id if id is not None else ''
2839        '''
2840         Unique identifier of the SecretStore.
2841        '''
2842        self.name = name if name is not None else ''
2843        '''
2844         Unique human-readable name of the SecretStore.
2845        '''
2846        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2847        '''
2848         Tags is a map of key, value pairs.
2849        '''
2850        self.vault_uri = vault_uri if vault_uri is not None else ''
2851        '''
2852
2853        '''
#   id

Unique identifier of the SecretStore.

#   name

Unique human-readable name of the SecretStore.

#   tags

Tags is a map of key, value pairs.

#   vault_uri
#   def to_dict(self):
View Source
2863    def to_dict(self):
2864        return {
2865            'id': self.id,
2866            'name': self.name,
2867            'tags': self.tags,
2868            'vault_uri': self.vault_uri,
2869        }
#  
@classmethod
def from_dict(cls, d):
View Source
2871    @classmethod
2872    def from_dict(cls, d):
2873        return cls(
2874            id=d.get('id'),
2875            name=d.get('name'),
2876            tags=d.get('tags'),
2877            vault_uri=d.get('vault_uri'),
2878        )
#   class BigQuery:
View Source
2881class BigQuery:
2882    '''
2883
2884    '''
2885    __slots__ = [
2886        'egress_filter',
2887        'endpoint',
2888        'healthy',
2889        'id',
2890        'name',
2891        'port_override',
2892        'private_key',
2893        'project',
2894        'secret_store_id',
2895        'tags',
2896        'username',
2897    ]
2898
2899    def __init__(
2900        self,
2901        egress_filter=None,
2902        endpoint=None,
2903        healthy=None,
2904        id=None,
2905        name=None,
2906        port_override=None,
2907        private_key=None,
2908        project=None,
2909        secret_store_id=None,
2910        tags=None,
2911        username=None,
2912    ):
2913        self.egress_filter = egress_filter if egress_filter is not None else ''
2914        '''
2915         A filter applied to the routing logic to pin datasource to nodes.
2916        '''
2917        self.endpoint = endpoint if endpoint is not None else ''
2918        '''
2919
2920        '''
2921        self.healthy = healthy if healthy is not None else False
2922        '''
2923         True if the datasource is reachable and the credentials are valid.
2924        '''
2925        self.id = id if id is not None else ''
2926        '''
2927         Unique identifier of the Resource.
2928        '''
2929        self.name = name if name is not None else ''
2930        '''
2931         Unique human-readable name of the Resource.
2932        '''
2933        self.port_override = port_override if port_override is not None else 0
2934        '''
2935
2936        '''
2937        self.private_key = private_key if private_key is not None else ''
2938        '''
2939
2940        '''
2941        self.project = project if project is not None else ''
2942        '''
2943
2944        '''
2945        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2946        '''
2947         ID of the secret store containing credentials for this resource, if any.
2948        '''
2949        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2950        '''
2951         Tags is a map of key, value pairs.
2952        '''
2953        self.username = username if username is not None else ''
2954        '''
2955
2956        '''
2957
2958    def __repr__(self):
2959        return '<sdm.BigQuery ' + \
2960            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2961            'endpoint: ' + repr(self.endpoint) + ' ' +\
2962            'healthy: ' + repr(self.healthy) + ' ' +\
2963            'id: ' + repr(self.id) + ' ' +\
2964            'name: ' + repr(self.name) + ' ' +\
2965            'port_override: ' + repr(self.port_override) + ' ' +\
2966            'private_key: ' + repr(self.private_key) + ' ' +\
2967            'project: ' + repr(self.project) + ' ' +\
2968            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2969            'tags: ' + repr(self.tags) + ' ' +\
2970            'username: ' + repr(self.username) + ' ' +\
2971            '>'
2972
2973    def to_dict(self):
2974        return {
2975            'egress_filter': self.egress_filter,
2976            'endpoint': self.endpoint,
2977            'healthy': self.healthy,
2978            'id': self.id,
2979            'name': self.name,
2980            'port_override': self.port_override,
2981            'private_key': self.private_key,
2982            'project': self.project,
2983            'secret_store_id': self.secret_store_id,
2984            'tags': self.tags,
2985            'username': self.username,
2986        }
2987
2988    @classmethod
2989    def from_dict(cls, d):
2990        return cls(
2991            egress_filter=d.get('egress_filter'),
2992            endpoint=d.get('endpoint'),
2993            healthy=d.get('healthy'),
2994            id=d.get('id'),
2995            name=d.get('name'),
2996            port_override=d.get('port_override'),
2997            private_key=d.get('private_key'),
2998            project=d.get('project'),
2999            secret_store_id=d.get('secret_store_id'),
3000            tags=d.get('tags'),
3001            username=d.get('username'),
3002        )
#   BigQuery( egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None )
View Source
2899    def __init__(
2900        self,
2901        egress_filter=None,
2902        endpoint=None,
2903        healthy=None,
2904        id=None,
2905        name=None,
2906        port_override=None,
2907        private_key=None,
2908        project=None,
2909        secret_store_id=None,
2910        tags=None,
2911        username=None,
2912    ):
2913        self.egress_filter = egress_filter if egress_filter is not None else ''
2914        '''
2915         A filter applied to the routing logic to pin datasource to nodes.
2916        '''
2917        self.endpoint = endpoint if endpoint is not None else ''
2918        '''
2919
2920        '''
2921        self.healthy = healthy if healthy is not None else False
2922        '''
2923         True if the datasource is reachable and the credentials are valid.
2924        '''
2925        self.id = id if id is not None else ''
2926        '''
2927         Unique identifier of the Resource.
2928        '''
2929        self.name = name if name is not None else ''
2930        '''
2931         Unique human-readable name of the Resource.
2932        '''
2933        self.port_override = port_override if port_override is not None else 0
2934        '''
2935
2936        '''
2937        self.private_key = private_key if private_key is not None else ''
2938        '''
2939
2940        '''
2941        self.project = project if project is not None else ''
2942        '''
2943
2944        '''
2945        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2946        '''
2947         ID of the secret store containing credentials for this resource, if any.
2948        '''
2949        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2950        '''
2951         Tags is a map of key, value pairs.
2952        '''
2953        self.username = username if username is not None else ''
2954        '''
2955
2956        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port_override
#   private_key
#   project
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
2973    def to_dict(self):
2974        return {
2975            'egress_filter': self.egress_filter,
2976            'endpoint': self.endpoint,
2977            'healthy': self.healthy,
2978            'id': self.id,
2979            'name': self.name,
2980            'port_override': self.port_override,
2981            'private_key': self.private_key,
2982            'project': self.project,
2983            'secret_store_id': self.secret_store_id,
2984            'tags': self.tags,
2985            'username': self.username,
2986        }
#  
@classmethod
def from_dict(cls, d):
View Source
2988    @classmethod
2989    def from_dict(cls, d):
2990        return cls(
2991            egress_filter=d.get('egress_filter'),
2992            endpoint=d.get('endpoint'),
2993            healthy=d.get('healthy'),
2994            id=d.get('id'),
2995            name=d.get('name'),
2996            port_override=d.get('port_override'),
2997            private_key=d.get('private_key'),
2998            project=d.get('project'),
2999            secret_store_id=d.get('secret_store_id'),
3000            tags=d.get('tags'),
3001            username=d.get('username'),
3002        )
#   class Cassandra:
View Source
3005class Cassandra:
3006    '''
3007
3008    '''
3009    __slots__ = [
3010        'egress_filter',
3011        'healthy',
3012        'hostname',
3013        'id',
3014        'name',
3015        'password',
3016        'port',
3017        'port_override',
3018        'secret_store_id',
3019        'tags',
3020        'tls_required',
3021        'username',
3022    ]
3023
3024    def __init__(
3025        self,
3026        egress_filter=None,
3027        healthy=None,
3028        hostname=None,
3029        id=None,
3030        name=None,
3031        password=None,
3032        port=None,
3033        port_override=None,
3034        secret_store_id=None,
3035        tags=None,
3036        tls_required=None,
3037        username=None,
3038    ):
3039        self.egress_filter = egress_filter if egress_filter is not None else ''
3040        '''
3041         A filter applied to the routing logic to pin datasource to nodes.
3042        '''
3043        self.healthy = healthy if healthy is not None else False
3044        '''
3045         True if the datasource is reachable and the credentials are valid.
3046        '''
3047        self.hostname = hostname if hostname is not None else ''
3048        '''
3049
3050        '''
3051        self.id = id if id is not None else ''
3052        '''
3053         Unique identifier of the Resource.
3054        '''
3055        self.name = name if name is not None else ''
3056        '''
3057         Unique human-readable name of the Resource.
3058        '''
3059        self.password = password if password is not None else ''
3060        '''
3061
3062        '''
3063        self.port = port if port is not None else 0
3064        '''
3065
3066        '''
3067        self.port_override = port_override if port_override is not None else 0
3068        '''
3069
3070        '''
3071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3072        '''
3073         ID of the secret store containing credentials for this resource, if any.
3074        '''
3075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3076        '''
3077         Tags is a map of key, value pairs.
3078        '''
3079        self.tls_required = tls_required if tls_required is not None else False
3080        '''
3081
3082        '''
3083        self.username = username if username is not None else ''
3084        '''
3085
3086        '''
3087
3088    def __repr__(self):
3089        return '<sdm.Cassandra ' + \
3090            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3091            'healthy: ' + repr(self.healthy) + ' ' +\
3092            'hostname: ' + repr(self.hostname) + ' ' +\
3093            'id: ' + repr(self.id) + ' ' +\
3094            'name: ' + repr(self.name) + ' ' +\
3095            'password: ' + repr(self.password) + ' ' +\
3096            'port: ' + repr(self.port) + ' ' +\
3097            'port_override: ' + repr(self.port_override) + ' ' +\
3098            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3099            'tags: ' + repr(self.tags) + ' ' +\
3100            'tls_required: ' + repr(self.tls_required) + ' ' +\
3101            'username: ' + repr(self.username) + ' ' +\
3102            '>'
3103
3104    def to_dict(self):
3105        return {
3106            'egress_filter': self.egress_filter,
3107            'healthy': self.healthy,
3108            'hostname': self.hostname,
3109            'id': self.id,
3110            'name': self.name,
3111            'password': self.password,
3112            'port': self.port,
3113            'port_override': self.port_override,
3114            'secret_store_id': self.secret_store_id,
3115            'tags': self.tags,
3116            'tls_required': self.tls_required,
3117            'username': self.username,
3118        }
3119
3120    @classmethod
3121    def from_dict(cls, d):
3122        return cls(
3123            egress_filter=d.get('egress_filter'),
3124            healthy=d.get('healthy'),
3125            hostname=d.get('hostname'),
3126            id=d.get('id'),
3127            name=d.get('name'),
3128            password=d.get('password'),
3129            port=d.get('port'),
3130            port_override=d.get('port_override'),
3131            secret_store_id=d.get('secret_store_id'),
3132            tags=d.get('tags'),
3133            tls_required=d.get('tls_required'),
3134            username=d.get('username'),
3135        )
#   Cassandra( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
3024    def __init__(
3025        self,
3026        egress_filter=None,
3027        healthy=None,
3028        hostname=None,
3029        id=None,
3030        name=None,
3031        password=None,
3032        port=None,
3033        port_override=None,
3034        secret_store_id=None,
3035        tags=None,
3036        tls_required=None,
3037        username=None,
3038    ):
3039        self.egress_filter = egress_filter if egress_filter is not None else ''
3040        '''
3041         A filter applied to the routing logic to pin datasource to nodes.
3042        '''
3043        self.healthy = healthy if healthy is not None else False
3044        '''
3045         True if the datasource is reachable and the credentials are valid.
3046        '''
3047        self.hostname = hostname if hostname is not None else ''
3048        '''
3049
3050        '''
3051        self.id = id if id is not None else ''
3052        '''
3053         Unique identifier of the Resource.
3054        '''
3055        self.name = name if name is not None else ''
3056        '''
3057         Unique human-readable name of the Resource.
3058        '''
3059        self.password = password if password is not None else ''
3060        '''
3061
3062        '''
3063        self.port = port if port is not None else 0
3064        '''
3065
3066        '''
3067        self.port_override = port_override if port_override is not None else 0
3068        '''
3069
3070        '''
3071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3072        '''
3073         ID of the secret store containing credentials for this resource, if any.
3074        '''
3075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3076        '''
3077         Tags is a map of key, value pairs.
3078        '''
3079        self.tls_required = tls_required if tls_required is not None else False
3080        '''
3081
3082        '''
3083        self.username = username if username is not None else ''
3084        '''
3085
3086        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
3104    def to_dict(self):
3105        return {
3106            'egress_filter': self.egress_filter,
3107            'healthy': self.healthy,
3108            'hostname': self.hostname,
3109            'id': self.id,
3110            'name': self.name,
3111            'password': self.password,
3112            'port': self.port,
3113            'port_override': self.port_override,
3114            'secret_store_id': self.secret_store_id,
3115            'tags': self.tags,
3116            'tls_required': self.tls_required,
3117            'username': self.username,
3118        }
#  
@classmethod
def from_dict(cls, d):
View Source
3120    @classmethod
3121    def from_dict(cls, d):
3122        return cls(
3123            egress_filter=d.get('egress_filter'),
3124            healthy=d.get('healthy'),
3125            hostname=d.get('hostname'),
3126            id=d.get('id'),
3127            name=d.get('name'),
3128            password=d.get('password'),
3129            port=d.get('port'),
3130            port_override=d.get('port_override'),
3131            secret_store_id=d.get('secret_store_id'),
3132            tags=d.get('tags'),
3133            tls_required=d.get('tls_required'),
3134            username=d.get('username'),
3135        )
#   class Citus:
View Source
3138class Citus:
3139    '''
3140
3141    '''
3142    __slots__ = [
3143        'database',
3144        'egress_filter',
3145        'healthy',
3146        'hostname',
3147        'id',
3148        'name',
3149        'override_database',
3150        'password',
3151        'port',
3152        'port_override',
3153        'secret_store_id',
3154        'tags',
3155        'username',
3156    ]
3157
3158    def __init__(
3159        self,
3160        database=None,
3161        egress_filter=None,
3162        healthy=None,
3163        hostname=None,
3164        id=None,
3165        name=None,
3166        override_database=None,
3167        password=None,
3168        port=None,
3169        port_override=None,
3170        secret_store_id=None,
3171        tags=None,
3172        username=None,
3173    ):
3174        self.database = database if database is not None else ''
3175        '''
3176
3177        '''
3178        self.egress_filter = egress_filter if egress_filter is not None else ''
3179        '''
3180         A filter applied to the routing logic to pin datasource to nodes.
3181        '''
3182        self.healthy = healthy if healthy is not None else False
3183        '''
3184         True if the datasource is reachable and the credentials are valid.
3185        '''
3186        self.hostname = hostname if hostname is not None else ''
3187        '''
3188
3189        '''
3190        self.id = id if id is not None else ''
3191        '''
3192         Unique identifier of the Resource.
3193        '''
3194        self.name = name if name is not None else ''
3195        '''
3196         Unique human-readable name of the Resource.
3197        '''
3198        self.override_database = override_database if override_database is not None else False
3199        '''
3200
3201        '''
3202        self.password = password if password is not None else ''
3203        '''
3204
3205        '''
3206        self.port = port if port is not None else 0
3207        '''
3208
3209        '''
3210        self.port_override = port_override if port_override is not None else 0
3211        '''
3212
3213        '''
3214        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3215        '''
3216         ID of the secret store containing credentials for this resource, if any.
3217        '''
3218        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3219        '''
3220         Tags is a map of key, value pairs.
3221        '''
3222        self.username = username if username is not None else ''
3223        '''
3224
3225        '''
3226
3227    def __repr__(self):
3228        return '<sdm.Citus ' + \
3229            'database: ' + repr(self.database) + ' ' +\
3230            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3231            'healthy: ' + repr(self.healthy) + ' ' +\
3232            'hostname: ' + repr(self.hostname) + ' ' +\
3233            'id: ' + repr(self.id) + ' ' +\
3234            'name: ' + repr(self.name) + ' ' +\
3235            'override_database: ' + repr(self.override_database) + ' ' +\
3236            'password: ' + repr(self.password) + ' ' +\
3237            'port: ' + repr(self.port) + ' ' +\
3238            'port_override: ' + repr(self.port_override) + ' ' +\
3239            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3240            'tags: ' + repr(self.tags) + ' ' +\
3241            'username: ' + repr(self.username) + ' ' +\
3242            '>'
3243
3244    def to_dict(self):
3245        return {
3246            'database': self.database,
3247            'egress_filter': self.egress_filter,
3248            'healthy': self.healthy,
3249            'hostname': self.hostname,
3250            'id': self.id,
3251            'name': self.name,
3252            'override_database': self.override_database,
3253            'password': self.password,
3254            'port': self.port,
3255            'port_override': self.port_override,
3256            'secret_store_id': self.secret_store_id,
3257            'tags': self.tags,
3258            'username': self.username,
3259        }
3260
3261    @classmethod
3262    def from_dict(cls, d):
3263        return cls(
3264            database=d.get('database'),
3265            egress_filter=d.get('egress_filter'),
3266            healthy=d.get('healthy'),
3267            hostname=d.get('hostname'),
3268            id=d.get('id'),
3269            name=d.get('name'),
3270            override_database=d.get('override_database'),
3271            password=d.get('password'),
3272            port=d.get('port'),
3273            port_override=d.get('port_override'),
3274            secret_store_id=d.get('secret_store_id'),
3275            tags=d.get('tags'),
3276            username=d.get('username'),
3277        )
#   Citus( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
3158    def __init__(
3159        self,
3160        database=None,
3161        egress_filter=None,
3162        healthy=None,
3163        hostname=None,
3164        id=None,
3165        name=None,
3166        override_database=None,
3167        password=None,
3168        port=None,
3169        port_override=None,
3170        secret_store_id=None,
3171        tags=None,
3172        username=None,
3173    ):
3174        self.database = database if database is not None else ''
3175        '''
3176
3177        '''
3178        self.egress_filter = egress_filter if egress_filter is not None else ''
3179        '''
3180         A filter applied to the routing logic to pin datasource to nodes.
3181        '''
3182        self.healthy = healthy if healthy is not None else False
3183        '''
3184         True if the datasource is reachable and the credentials are valid.
3185        '''
3186        self.hostname = hostname if hostname is not None else ''
3187        '''
3188
3189        '''
3190        self.id = id if id is not None else ''
3191        '''
3192         Unique identifier of the Resource.
3193        '''
3194        self.name = name if name is not None else ''
3195        '''
3196         Unique human-readable name of the Resource.
3197        '''
3198        self.override_database = override_database if override_database is not None else False
3199        '''
3200
3201        '''
3202        self.password = password if password is not None else ''
3203        '''
3204
3205        '''
3206        self.port = port if port is not None else 0
3207        '''
3208
3209        '''
3210        self.port_override = port_override if port_override is not None else 0
3211        '''
3212
3213        '''
3214        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3215        '''
3216         ID of the secret store containing credentials for this resource, if any.
3217        '''
3218        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3219        '''
3220         Tags is a map of key, value pairs.
3221        '''
3222        self.username = username if username is not None else ''
3223        '''
3224
3225        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
3244    def to_dict(self):
3245        return {
3246            'database': self.database,
3247            'egress_filter': self.egress_filter,
3248            'healthy': self.healthy,
3249            'hostname': self.hostname,
3250            'id': self.id,
3251            'name': self.name,
3252            'override_database': self.override_database,
3253            'password': self.password,
3254            'port': self.port,
3255            'port_override': self.port_override,
3256            'secret_store_id': self.secret_store_id,
3257            'tags': self.tags,
3258            'username': self.username,
3259        }
#  
@classmethod
def from_dict(cls, d):
View Source
3261    @classmethod
3262    def from_dict(cls, d):
3263        return cls(
3264            database=d.get('database'),
3265            egress_filter=d.get('egress_filter'),
3266            healthy=d.get('healthy'),
3267            hostname=d.get('hostname'),
3268            id=d.get('id'),
3269            name=d.get('name'),
3270            override_database=d.get('override_database'),
3271            password=d.get('password'),
3272            port=d.get('port'),
3273            port_override=d.get('port_override'),
3274            secret_store_id=d.get('secret_store_id'),
3275            tags=d.get('tags'),
3276            username=d.get('username'),
3277        )
#   class Clustrix:
View Source
3280class Clustrix:
3281    '''
3282
3283    '''
3284    __slots__ = [
3285        'database',
3286        'egress_filter',
3287        'healthy',
3288        'hostname',
3289        'id',
3290        'name',
3291        'password',
3292        'port',
3293        'port_override',
3294        'secret_store_id',
3295        'tags',
3296        'username',
3297    ]
3298
3299    def __init__(
3300        self,
3301        database=None,
3302        egress_filter=None,
3303        healthy=None,
3304        hostname=None,
3305        id=None,
3306        name=None,
3307        password=None,
3308        port=None,
3309        port_override=None,
3310        secret_store_id=None,
3311        tags=None,
3312        username=None,
3313    ):
3314        self.database = database if database is not None else ''
3315        '''
3316
3317        '''
3318        self.egress_filter = egress_filter if egress_filter is not None else ''
3319        '''
3320         A filter applied to the routing logic to pin datasource to nodes.
3321        '''
3322        self.healthy = healthy if healthy is not None else False
3323        '''
3324         True if the datasource is reachable and the credentials are valid.
3325        '''
3326        self.hostname = hostname if hostname is not None else ''
3327        '''
3328
3329        '''
3330        self.id = id if id is not None else ''
3331        '''
3332         Unique identifier of the Resource.
3333        '''
3334        self.name = name if name is not None else ''
3335        '''
3336         Unique human-readable name of the Resource.
3337        '''
3338        self.password = password if password is not None else ''
3339        '''
3340
3341        '''
3342        self.port = port if port is not None else 0
3343        '''
3344
3345        '''
3346        self.port_override = port_override if port_override is not None else 0
3347        '''
3348
3349        '''
3350        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3351        '''
3352         ID of the secret store containing credentials for this resource, if any.
3353        '''
3354        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3355        '''
3356         Tags is a map of key, value pairs.
3357        '''
3358        self.username = username if username is not None else ''
3359        '''
3360
3361        '''
3362
3363    def __repr__(self):
3364        return '<sdm.Clustrix ' + \
3365            'database: ' + repr(self.database) + ' ' +\
3366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3367            'healthy: ' + repr(self.healthy) + ' ' +\
3368            'hostname: ' + repr(self.hostname) + ' ' +\
3369            'id: ' + repr(self.id) + ' ' +\
3370            'name: ' + repr(self.name) + ' ' +\
3371            'password: ' + repr(self.password) + ' ' +\
3372            'port: ' + repr(self.port) + ' ' +\
3373            'port_override: ' + repr(self.port_override) + ' ' +\
3374            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3375            'tags: ' + repr(self.tags) + ' ' +\
3376            'username: ' + repr(self.username) + ' ' +\
3377            '>'
3378
3379    def to_dict(self):
3380        return {
3381            'database': self.database,
3382            'egress_filter': self.egress_filter,
3383            'healthy': self.healthy,
3384            'hostname': self.hostname,
3385            'id': self.id,
3386            'name': self.name,
3387            'password': self.password,
3388            'port': self.port,
3389            'port_override': self.port_override,
3390            'secret_store_id': self.secret_store_id,
3391            'tags': self.tags,
3392            'username': self.username,
3393        }
3394
3395    @classmethod
3396    def from_dict(cls, d):
3397        return cls(
3398            database=d.get('database'),
3399            egress_filter=d.get('egress_filter'),
3400            healthy=d.get('healthy'),
3401            hostname=d.get('hostname'),
3402            id=d.get('id'),
3403            name=d.get('name'),
3404            password=d.get('password'),
3405            port=d.get('port'),
3406            port_override=d.get('port_override'),
3407            secret_store_id=d.get('secret_store_id'),
3408            tags=d.get('tags'),
3409            username=d.get('username'),
3410        )
#   Clustrix( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
3299    def __init__(
3300        self,
3301        database=None,
3302        egress_filter=None,
3303        healthy=None,
3304        hostname=None,
3305        id=None,
3306        name=None,
3307        password=None,
3308        port=None,
3309        port_override=None,
3310        secret_store_id=None,
3311        tags=None,
3312        username=None,
3313    ):
3314        self.database = database if database is not None else ''
3315        '''
3316
3317        '''
3318        self.egress_filter = egress_filter if egress_filter is not None else ''
3319        '''
3320         A filter applied to the routing logic to pin datasource to nodes.
3321        '''
3322        self.healthy = healthy if healthy is not None else False
3323        '''
3324         True if the datasource is reachable and the credentials are valid.
3325        '''
3326        self.hostname = hostname if hostname is not None else ''
3327        '''
3328
3329        '''
3330        self.id = id if id is not None else ''
3331        '''
3332         Unique identifier of the Resource.
3333        '''
3334        self.name = name if name is not None else ''
3335        '''
3336         Unique human-readable name of the Resource.
3337        '''
3338        self.password = password if password is not None else ''
3339        '''
3340
3341        '''
3342        self.port = port if port is not None else 0
3343        '''
3344
3345        '''
3346        self.port_override = port_override if port_override is not None else 0
3347        '''
3348
3349        '''
3350        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3351        '''
3352         ID of the secret store containing credentials for this resource, if any.
3353        '''
3354        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3355        '''
3356         Tags is a map of key, value pairs.
3357        '''
3358        self.username = username if username is not None else ''
3359        '''
3360
3361        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
3379    def to_dict(self):
3380        return {
3381            'database': self.database,
3382            'egress_filter': self.egress_filter,
3383            'healthy': self.healthy,
3384            'hostname': self.hostname,
3385            'id': self.id,
3386            'name': self.name,
3387            'password': self.password,
3388            'port': self.port,
3389            'port_override': self.port_override,
3390            'secret_store_id': self.secret_store_id,
3391            'tags': self.tags,
3392            'username': self.username,
3393        }
#  
@classmethod
def from_dict(cls, d):
View Source
3395    @classmethod
3396    def from_dict(cls, d):
3397        return cls(
3398            database=d.get('database'),
3399            egress_filter=d.get('egress_filter'),
3400            healthy=d.get('healthy'),
3401            hostname=d.get('hostname'),
3402            id=d.get('id'),
3403            name=d.get('name'),
3404            password=d.get('password'),
3405            port=d.get('port'),
3406            port_override=d.get('port_override'),
3407            secret_store_id=d.get('secret_store_id'),
3408            tags=d.get('tags'),
3409            username=d.get('username'),
3410        )
#   class Cockroach:
View Source
3413class Cockroach:
3414    '''
3415
3416    '''
3417    __slots__ = [
3418        'database',
3419        'egress_filter',
3420        'healthy',
3421        'hostname',
3422        'id',
3423        'name',
3424        'override_database',
3425        'password',
3426        'port',
3427        'port_override',
3428        'secret_store_id',
3429        'tags',
3430        'username',
3431    ]
3432
3433    def __init__(
3434        self,
3435        database=None,
3436        egress_filter=None,
3437        healthy=None,
3438        hostname=None,
3439        id=None,
3440        name=None,
3441        override_database=None,
3442        password=None,
3443        port=None,
3444        port_override=None,
3445        secret_store_id=None,
3446        tags=None,
3447        username=None,
3448    ):
3449        self.database = database if database is not None else ''
3450        '''
3451
3452        '''
3453        self.egress_filter = egress_filter if egress_filter is not None else ''
3454        '''
3455         A filter applied to the routing logic to pin datasource to nodes.
3456        '''
3457        self.healthy = healthy if healthy is not None else False
3458        '''
3459         True if the datasource is reachable and the credentials are valid.
3460        '''
3461        self.hostname = hostname if hostname is not None else ''
3462        '''
3463
3464        '''
3465        self.id = id if id is not None else ''
3466        '''
3467         Unique identifier of the Resource.
3468        '''
3469        self.name = name if name is not None else ''
3470        '''
3471         Unique human-readable name of the Resource.
3472        '''
3473        self.override_database = override_database if override_database is not None else False
3474        '''
3475
3476        '''
3477        self.password = password if password is not None else ''
3478        '''
3479
3480        '''
3481        self.port = port if port is not None else 0
3482        '''
3483
3484        '''
3485        self.port_override = port_override if port_override is not None else 0
3486        '''
3487
3488        '''
3489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3490        '''
3491         ID of the secret store containing credentials for this resource, if any.
3492        '''
3493        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3494        '''
3495         Tags is a map of key, value pairs.
3496        '''
3497        self.username = username if username is not None else ''
3498        '''
3499
3500        '''
3501
3502    def __repr__(self):
3503        return '<sdm.Cockroach ' + \
3504            'database: ' + repr(self.database) + ' ' +\
3505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3506            'healthy: ' + repr(self.healthy) + ' ' +\
3507            'hostname: ' + repr(self.hostname) + ' ' +\
3508            'id: ' + repr(self.id) + ' ' +\
3509            'name: ' + repr(self.name) + ' ' +\
3510            'override_database: ' + repr(self.override_database) + ' ' +\
3511            'password: ' + repr(self.password) + ' ' +\
3512            'port: ' + repr(self.port) + ' ' +\
3513            'port_override: ' + repr(self.port_override) + ' ' +\
3514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3515            'tags: ' + repr(self.tags) + ' ' +\
3516            'username: ' + repr(self.username) + ' ' +\
3517            '>'
3518
3519    def to_dict(self):
3520        return {
3521            'database': self.database,
3522            'egress_filter': self.egress_filter,
3523            'healthy': self.healthy,
3524            'hostname': self.hostname,
3525            'id': self.id,
3526            'name': self.name,
3527            'override_database': self.override_database,
3528            'password': self.password,
3529            'port': self.port,
3530            'port_override': self.port_override,
3531            'secret_store_id': self.secret_store_id,
3532            'tags': self.tags,
3533            'username': self.username,
3534        }
3535
3536    @classmethod
3537    def from_dict(cls, d):
3538        return cls(
3539            database=d.get('database'),
3540            egress_filter=d.get('egress_filter'),
3541            healthy=d.get('healthy'),
3542            hostname=d.get('hostname'),
3543            id=d.get('id'),
3544            name=d.get('name'),
3545            override_database=d.get('override_database'),
3546            password=d.get('password'),
3547            port=d.get('port'),
3548            port_override=d.get('port_override'),
3549            secret_store_id=d.get('secret_store_id'),
3550            tags=d.get('tags'),
3551            username=d.get('username'),
3552        )
#   Cockroach( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
3433    def __init__(
3434        self,
3435        database=None,
3436        egress_filter=None,
3437        healthy=None,
3438        hostname=None,
3439        id=None,
3440        name=None,
3441        override_database=None,
3442        password=None,
3443        port=None,
3444        port_override=None,
3445        secret_store_id=None,
3446        tags=None,
3447        username=None,
3448    ):
3449        self.database = database if database is not None else ''
3450        '''
3451
3452        '''
3453        self.egress_filter = egress_filter if egress_filter is not None else ''
3454        '''
3455         A filter applied to the routing logic to pin datasource to nodes.
3456        '''
3457        self.healthy = healthy if healthy is not None else False
3458        '''
3459         True if the datasource is reachable and the credentials are valid.
3460        '''
3461        self.hostname = hostname if hostname is not None else ''
3462        '''
3463
3464        '''
3465        self.id = id if id is not None else ''
3466        '''
3467         Unique identifier of the Resource.
3468        '''
3469        self.name = name if name is not None else ''
3470        '''
3471         Unique human-readable name of the Resource.
3472        '''
3473        self.override_database = override_database if override_database is not None else False
3474        '''
3475
3476        '''
3477        self.password = password if password is not None else ''
3478        '''
3479
3480        '''
3481        self.port = port if port is not None else 0
3482        '''
3483
3484        '''
3485        self.port_override = port_override if port_override is not None else 0
3486        '''
3487
3488        '''
3489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3490        '''
3491         ID of the secret store containing credentials for this resource, if any.
3492        '''
3493        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3494        '''
3495         Tags is a map of key, value pairs.
3496        '''
3497        self.username = username if username is not None else ''
3498        '''
3499
3500        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
3519    def to_dict(self):
3520        return {
3521            'database': self.database,
3522            'egress_filter': self.egress_filter,
3523            'healthy': self.healthy,
3524            'hostname': self.hostname,
3525            'id': self.id,
3526            'name': self.name,
3527            'override_database': self.override_database,
3528            'password': self.password,
3529            'port': self.port,
3530            'port_override': self.port_override,
3531            'secret_store_id': self.secret_store_id,
3532            'tags': self.tags,
3533            'username': self.username,
3534        }
#  
@classmethod
def from_dict(cls, d):
View Source
3536    @classmethod
3537    def from_dict(cls, d):
3538        return cls(
3539            database=d.get('database'),
3540            egress_filter=d.get('egress_filter'),
3541            healthy=d.get('healthy'),
3542            hostname=d.get('hostname'),
3543            id=d.get('id'),
3544            name=d.get('name'),
3545            override_database=d.get('override_database'),
3546            password=d.get('password'),
3547            port=d.get('port'),
3548            port_override=d.get('port_override'),
3549            secret_store_id=d.get('secret_store_id'),
3550            tags=d.get('tags'),
3551            username=d.get('username'),
3552        )
#   class ControlPanelGetSSHCAPublicKeyResponse:
View Source
3555class ControlPanelGetSSHCAPublicKeyResponse:
3556    '''
3557     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3558     organization's SSH Certificate Authority public key.
3559    '''
3560    __slots__ = [
3561        'meta',
3562        'public_key',
3563        'rate_limit',
3564    ]
3565
3566    def __init__(
3567        self,
3568        meta=None,
3569        public_key=None,
3570        rate_limit=None,
3571    ):
3572        self.meta = meta if meta is not None else None
3573        '''
3574         Reserved for future use.
3575        '''
3576        self.public_key = public_key if public_key is not None else ''
3577        '''
3578         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3579         key format.
3580        '''
3581        self.rate_limit = rate_limit if rate_limit is not None else None
3582        '''
3583         Rate limit information.
3584        '''
3585
3586    def __repr__(self):
3587        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3588            'meta: ' + repr(self.meta) + ' ' +\
3589            'public_key: ' + repr(self.public_key) + ' ' +\
3590            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3591            '>'
3592
3593    def to_dict(self):
3594        return {
3595            'meta': self.meta,
3596            'public_key': self.public_key,
3597            'rate_limit': self.rate_limit,
3598        }
3599
3600    @classmethod
3601    def from_dict(cls, d):
3602        return cls(
3603            meta=d.get('meta'),
3604            public_key=d.get('public_key'),
3605            rate_limit=d.get('rate_limit'),
3606        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

#   ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
View Source
3566    def __init__(
3567        self,
3568        meta=None,
3569        public_key=None,
3570        rate_limit=None,
3571    ):
3572        self.meta = meta if meta is not None else None
3573        '''
3574         Reserved for future use.
3575        '''
3576        self.public_key = public_key if public_key is not None else ''
3577        '''
3578         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3579         key format.
3580        '''
3581        self.rate_limit = rate_limit if rate_limit is not None else None
3582        '''
3583         Rate limit information.
3584        '''
#   meta

Reserved for future use.

#   public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
3593    def to_dict(self):
3594        return {
3595            'meta': self.meta,
3596            'public_key': self.public_key,
3597            'rate_limit': self.rate_limit,
3598        }
#  
@classmethod
def from_dict(cls, d):
View Source
3600    @classmethod
3601    def from_dict(cls, d):
3602        return cls(
3603            meta=d.get('meta'),
3604            public_key=d.get('public_key'),
3605            rate_limit=d.get('rate_limit'),
3606        )
#   class ControlPanelVerifyJWTResponse:
View Source
3609class ControlPanelVerifyJWTResponse:
3610    '''
3611     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3612    '''
3613    __slots__ = [
3614        'meta',
3615        'rate_limit',
3616        'valid',
3617    ]
3618
3619    def __init__(
3620        self,
3621        meta=None,
3622        rate_limit=None,
3623        valid=None,
3624    ):
3625        self.meta = meta if meta is not None else None
3626        '''
3627         Reserved for future use.
3628        '''
3629        self.rate_limit = rate_limit if rate_limit is not None else None
3630        '''
3631         Rate limit information.
3632        '''
3633        self.valid = valid if valid is not None else False
3634        '''
3635         Reports if the given token is valid.
3636        '''
3637
3638    def __repr__(self):
3639        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3640            'meta: ' + repr(self.meta) + ' ' +\
3641            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3642            'valid: ' + repr(self.valid) + ' ' +\
3643            '>'
3644
3645    def to_dict(self):
3646        return {
3647            'meta': self.meta,
3648            'rate_limit': self.rate_limit,
3649            'valid': self.valid,
3650        }
3651
3652    @classmethod
3653    def from_dict(cls, d):
3654        return cls(
3655            meta=d.get('meta'),
3656            rate_limit=d.get('rate_limit'),
3657            valid=d.get('valid'),
3658        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

#   ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
View Source
3619    def __init__(
3620        self,
3621        meta=None,
3622        rate_limit=None,
3623        valid=None,
3624    ):
3625        self.meta = meta if meta is not None else None
3626        '''
3627         Reserved for future use.
3628        '''
3629        self.rate_limit = rate_limit if rate_limit is not None else None
3630        '''
3631         Rate limit information.
3632        '''
3633        self.valid = valid if valid is not None else False
3634        '''
3635         Reports if the given token is valid.
3636        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   valid

Reports if the given token is valid.

#   def to_dict(self):
View Source
3645    def to_dict(self):
3646        return {
3647            'meta': self.meta,
3648            'rate_limit': self.rate_limit,
3649            'valid': self.valid,
3650        }
#  
@classmethod
def from_dict(cls, d):
View Source
3652    @classmethod
3653    def from_dict(cls, d):
3654        return cls(
3655            meta=d.get('meta'),
3656            rate_limit=d.get('rate_limit'),
3657            valid=d.get('valid'),
3658        )
#   class CreateResponseMetadata:
View Source
3661class CreateResponseMetadata:
3662    '''
3663     CreateResponseMetadata is reserved for future use.
3664    '''
3665    __slots__ = []
3666
3667    def __init__(self, ):
3668        pass
3669
3670    def __repr__(self):
3671        return '<sdm.CreateResponseMetadata ' + \
3672            '>'
3673
3674    def to_dict(self):
3675        return {}
3676
3677    @classmethod
3678    def from_dict(cls, d):
3679        return cls()

CreateResponseMetadata is reserved for future use.

#   CreateResponseMetadata()
View Source
3667    def __init__(self, ):
3668        pass
#   def to_dict(self):
View Source
3674    def to_dict(self):
3675        return {}
#  
@classmethod
def from_dict(cls, d):
View Source
3677    @classmethod
3678    def from_dict(cls, d):
3679        return cls()
#   class DB2I:
View Source
3682class DB2I:
3683    '''
3684
3685    '''
3686    __slots__ = [
3687        'egress_filter',
3688        'healthy',
3689        'hostname',
3690        'id',
3691        'name',
3692        'password',
3693        'port',
3694        'port_override',
3695        'secret_store_id',
3696        'tags',
3697        'tls_required',
3698        'username',
3699    ]
3700
3701    def __init__(
3702        self,
3703        egress_filter=None,
3704        healthy=None,
3705        hostname=None,
3706        id=None,
3707        name=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        tls_required=None,
3714        username=None,
3715    ):
3716        self.egress_filter = egress_filter if egress_filter is not None else ''
3717        '''
3718         A filter applied to the routing logic to pin datasource to nodes.
3719        '''
3720        self.healthy = healthy if healthy is not None else False
3721        '''
3722         True if the datasource is reachable and the credentials are valid.
3723        '''
3724        self.hostname = hostname if hostname is not None else ''
3725        '''
3726
3727        '''
3728        self.id = id if id is not None else ''
3729        '''
3730         Unique identifier of the Resource.
3731        '''
3732        self.name = name if name is not None else ''
3733        '''
3734         Unique human-readable name of the Resource.
3735        '''
3736        self.password = password if password is not None else ''
3737        '''
3738
3739        '''
3740        self.port = port if port is not None else 0
3741        '''
3742
3743        '''
3744        self.port_override = port_override if port_override is not None else 0
3745        '''
3746
3747        '''
3748        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3749        '''
3750         ID of the secret store containing credentials for this resource, if any.
3751        '''
3752        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3753        '''
3754         Tags is a map of key, value pairs.
3755        '''
3756        self.tls_required = tls_required if tls_required is not None else False
3757        '''
3758
3759        '''
3760        self.username = username if username is not None else ''
3761        '''
3762
3763        '''
3764
3765    def __repr__(self):
3766        return '<sdm.DB2I ' + \
3767            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3768            'healthy: ' + repr(self.healthy) + ' ' +\
3769            'hostname: ' + repr(self.hostname) + ' ' +\
3770            'id: ' + repr(self.id) + ' ' +\
3771            'name: ' + repr(self.name) + ' ' +\
3772            'password: ' + repr(self.password) + ' ' +\
3773            'port: ' + repr(self.port) + ' ' +\
3774            'port_override: ' + repr(self.port_override) + ' ' +\
3775            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3776            'tags: ' + repr(self.tags) + ' ' +\
3777            'tls_required: ' + repr(self.tls_required) + ' ' +\
3778            'username: ' + repr(self.username) + ' ' +\
3779            '>'
3780
3781    def to_dict(self):
3782        return {
3783            'egress_filter': self.egress_filter,
3784            'healthy': self.healthy,
3785            'hostname': self.hostname,
3786            'id': self.id,
3787            'name': self.name,
3788            'password': self.password,
3789            'port': self.port,
3790            'port_override': self.port_override,
3791            'secret_store_id': self.secret_store_id,
3792            'tags': self.tags,
3793            'tls_required': self.tls_required,
3794            'username': self.username,
3795        }
3796
3797    @classmethod
3798    def from_dict(cls, d):
3799        return cls(
3800            egress_filter=d.get('egress_filter'),
3801            healthy=d.get('healthy'),
3802            hostname=d.get('hostname'),
3803            id=d.get('id'),
3804            name=d.get('name'),
3805            password=d.get('password'),
3806            port=d.get('port'),
3807            port_override=d.get('port_override'),
3808            secret_store_id=d.get('secret_store_id'),
3809            tags=d.get('tags'),
3810            tls_required=d.get('tls_required'),
3811            username=d.get('username'),
3812        )
#   DB2I( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
3701    def __init__(
3702        self,
3703        egress_filter=None,
3704        healthy=None,
3705        hostname=None,
3706        id=None,
3707        name=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        tls_required=None,
3714        username=None,
3715    ):
3716        self.egress_filter = egress_filter if egress_filter is not None else ''
3717        '''
3718         A filter applied to the routing logic to pin datasource to nodes.
3719        '''
3720        self.healthy = healthy if healthy is not None else False
3721        '''
3722         True if the datasource is reachable and the credentials are valid.
3723        '''
3724        self.hostname = hostname if hostname is not None else ''
3725        '''
3726
3727        '''
3728        self.id = id if id is not None else ''
3729        '''
3730         Unique identifier of the Resource.
3731        '''
3732        self.name = name if name is not None else ''
3733        '''
3734         Unique human-readable name of the Resource.
3735        '''
3736        self.password = password if password is not None else ''
3737        '''
3738
3739        '''
3740        self.port = port if port is not None else 0
3741        '''
3742
3743        '''
3744        self.port_override = port_override if port_override is not None else 0
3745        '''
3746
3747        '''
3748        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3749        '''
3750         ID of the secret store containing credentials for this resource, if any.
3751        '''
3752        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3753        '''
3754         Tags is a map of key, value pairs.
3755        '''
3756        self.tls_required = tls_required if tls_required is not None else False
3757        '''
3758
3759        '''
3760        self.username = username if username is not None else ''
3761        '''
3762
3763        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
3781    def to_dict(self):
3782        return {
3783            'egress_filter': self.egress_filter,
3784            'healthy': self.healthy,
3785            'hostname': self.hostname,
3786            'id': self.id,
3787            'name': self.name,
3788            'password': self.password,
3789            'port': self.port,
3790            'port_override': self.port_override,
3791            'secret_store_id': self.secret_store_id,
3792            'tags': self.tags,
3793            'tls_required': self.tls_required,
3794            'username': self.username,
3795        }
#  
@classmethod
def from_dict(cls, d):
View Source
3797    @classmethod
3798    def from_dict(cls, d):
3799        return cls(
3800            egress_filter=d.get('egress_filter'),
3801            healthy=d.get('healthy'),
3802            hostname=d.get('hostname'),
3803            id=d.get('id'),
3804            name=d.get('name'),
3805            password=d.get('password'),
3806            port=d.get('port'),
3807            port_override=d.get('port_override'),
3808            secret_store_id=d.get('secret_store_id'),
3809            tags=d.get('tags'),
3810            tls_required=d.get('tls_required'),
3811            username=d.get('username'),
3812        )
#   class DB2LUW:
View Source
3815class DB2LUW:
3816    '''
3817
3818    '''
3819    __slots__ = [
3820        'database',
3821        'egress_filter',
3822        'healthy',
3823        'hostname',
3824        'id',
3825        'name',
3826        'password',
3827        'port',
3828        'port_override',
3829        'secret_store_id',
3830        'tags',
3831        'username',
3832    ]
3833
3834    def __init__(
3835        self,
3836        database=None,
3837        egress_filter=None,
3838        healthy=None,
3839        hostname=None,
3840        id=None,
3841        name=None,
3842        password=None,
3843        port=None,
3844        port_override=None,
3845        secret_store_id=None,
3846        tags=None,
3847        username=None,
3848    ):
3849        self.database = database if database is not None else ''
3850        '''
3851
3852        '''
3853        self.egress_filter = egress_filter if egress_filter is not None else ''
3854        '''
3855         A filter applied to the routing logic to pin datasource to nodes.
3856        '''
3857        self.healthy = healthy if healthy is not None else False
3858        '''
3859         True if the datasource is reachable and the credentials are valid.
3860        '''
3861        self.hostname = hostname if hostname is not None else ''
3862        '''
3863
3864        '''
3865        self.id = id if id is not None else ''
3866        '''
3867         Unique identifier of the Resource.
3868        '''
3869        self.name = name if name is not None else ''
3870        '''
3871         Unique human-readable name of the Resource.
3872        '''
3873        self.password = password if password is not None else ''
3874        '''
3875
3876        '''
3877        self.port = port if port is not None else 0
3878        '''
3879
3880        '''
3881        self.port_override = port_override if port_override is not None else 0
3882        '''
3883
3884        '''
3885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3886        '''
3887         ID of the secret store containing credentials for this resource, if any.
3888        '''
3889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3890        '''
3891         Tags is a map of key, value pairs.
3892        '''
3893        self.username = username if username is not None else ''
3894        '''
3895
3896        '''
3897
3898    def __repr__(self):
3899        return '<sdm.DB2LUW ' + \
3900            'database: ' + repr(self.database) + ' ' +\
3901            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3902            'healthy: ' + repr(self.healthy) + ' ' +\
3903            'hostname: ' + repr(self.hostname) + ' ' +\
3904            'id: ' + repr(self.id) + ' ' +\
3905            'name: ' + repr(self.name) + ' ' +\
3906            'password: ' + repr(self.password) + ' ' +\
3907            'port: ' + repr(self.port) + ' ' +\
3908            'port_override: ' + repr(self.port_override) + ' ' +\
3909            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3910            'tags: ' + repr(self.tags) + ' ' +\
3911            'username: ' + repr(self.username) + ' ' +\
3912            '>'
3913
3914    def to_dict(self):
3915        return {
3916            'database': self.database,
3917            'egress_filter': self.egress_filter,
3918            'healthy': self.healthy,
3919            'hostname': self.hostname,
3920            'id': self.id,
3921            'name': self.name,
3922            'password': self.password,
3923            'port': self.port,
3924            'port_override': self.port_override,
3925            'secret_store_id': self.secret_store_id,
3926            'tags': self.tags,
3927            'username': self.username,
3928        }
3929
3930    @classmethod
3931    def from_dict(cls, d):
3932        return cls(
3933            database=d.get('database'),
3934            egress_filter=d.get('egress_filter'),
3935            healthy=d.get('healthy'),
3936            hostname=d.get('hostname'),
3937            id=d.get('id'),
3938            name=d.get('name'),
3939            password=d.get('password'),
3940            port=d.get('port'),
3941            port_override=d.get('port_override'),
3942            secret_store_id=d.get('secret_store_id'),
3943            tags=d.get('tags'),
3944            username=d.get('username'),
3945        )
#   DB2LUW( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
3834    def __init__(
3835        self,
3836        database=None,
3837        egress_filter=None,
3838        healthy=None,
3839        hostname=None,
3840        id=None,
3841        name=None,
3842        password=None,
3843        port=None,
3844        port_override=None,
3845        secret_store_id=None,
3846        tags=None,
3847        username=None,
3848    ):
3849        self.database = database if database is not None else ''
3850        '''
3851
3852        '''
3853        self.egress_filter = egress_filter if egress_filter is not None else ''
3854        '''
3855         A filter applied to the routing logic to pin datasource to nodes.
3856        '''
3857        self.healthy = healthy if healthy is not None else False
3858        '''
3859         True if the datasource is reachable and the credentials are valid.
3860        '''
3861        self.hostname = hostname if hostname is not None else ''
3862        '''
3863
3864        '''
3865        self.id = id if id is not None else ''
3866        '''
3867         Unique identifier of the Resource.
3868        '''
3869        self.name = name if name is not None else ''
3870        '''
3871         Unique human-readable name of the Resource.
3872        '''
3873        self.password = password if password is not None else ''
3874        '''
3875
3876        '''
3877        self.port = port if port is not None else 0
3878        '''
3879
3880        '''
3881        self.port_override = port_override if port_override is not None else 0
3882        '''
3883
3884        '''
3885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3886        '''
3887         ID of the secret store containing credentials for this resource, if any.
3888        '''
3889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3890        '''
3891         Tags is a map of key, value pairs.
3892        '''
3893        self.username = username if username is not None else ''
3894        '''
3895
3896        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
3914    def to_dict(self):
3915        return {
3916            'database': self.database,
3917            'egress_filter': self.egress_filter,
3918            'healthy': self.healthy,
3919            'hostname': self.hostname,
3920            'id': self.id,
3921            'name': self.name,
3922            'password': self.password,
3923            'port': self.port,
3924            'port_override': self.port_override,
3925            'secret_store_id': self.secret_store_id,
3926            'tags': self.tags,
3927            'username': self.username,
3928        }
#  
@classmethod
def from_dict(cls, d):
View Source
3930    @classmethod
3931    def from_dict(cls, d):
3932        return cls(
3933            database=d.get('database'),
3934            egress_filter=d.get('egress_filter'),
3935            healthy=d.get('healthy'),
3936            hostname=d.get('hostname'),
3937            id=d.get('id'),
3938            name=d.get('name'),
3939            password=d.get('password'),
3940            port=d.get('port'),
3941            port_override=d.get('port_override'),
3942            secret_store_id=d.get('secret_store_id'),
3943            tags=d.get('tags'),
3944            username=d.get('username'),
3945        )
#   class DeleteResponseMetadata:
View Source
3948class DeleteResponseMetadata:
3949    '''
3950     DeleteResponseMetadata is reserved for future use.
3951    '''
3952    __slots__ = []
3953
3954    def __init__(self, ):
3955        pass
3956
3957    def __repr__(self):
3958        return '<sdm.DeleteResponseMetadata ' + \
3959            '>'
3960
3961    def to_dict(self):
3962        return {}
3963
3964    @classmethod
3965    def from_dict(cls, d):
3966        return cls()

DeleteResponseMetadata is reserved for future use.

#   DeleteResponseMetadata()
View Source
3954    def __init__(self, ):
3955        pass
#   def to_dict(self):
View Source
3961    def to_dict(self):
3962        return {}
#  
@classmethod
def from_dict(cls, d):
View Source
3964    @classmethod
3965    def from_dict(cls, d):
3966        return cls()
#   class DocumentDBHost:
View Source
3969class DocumentDBHost:
3970    '''
3971
3972    '''
3973    __slots__ = [
3974        'auth_database',
3975        'egress_filter',
3976        'healthy',
3977        'hostname',
3978        'id',
3979        'name',
3980        'password',
3981        'port',
3982        'port_override',
3983        'secret_store_id',
3984        'tags',
3985        'username',
3986    ]
3987
3988    def __init__(
3989        self,
3990        auth_database=None,
3991        egress_filter=None,
3992        healthy=None,
3993        hostname=None,
3994        id=None,
3995        name=None,
3996        password=None,
3997        port=None,
3998        port_override=None,
3999        secret_store_id=None,
4000        tags=None,
4001        username=None,
4002    ):
4003        self.auth_database = auth_database if auth_database is not None else ''
4004        '''
4005
4006        '''
4007        self.egress_filter = egress_filter if egress_filter is not None else ''
4008        '''
4009         A filter applied to the routing logic to pin datasource to nodes.
4010        '''
4011        self.healthy = healthy if healthy is not None else False
4012        '''
4013         True if the datasource is reachable and the credentials are valid.
4014        '''
4015        self.hostname = hostname if hostname is not None else ''
4016        '''
4017
4018        '''
4019        self.id = id if id is not None else ''
4020        '''
4021         Unique identifier of the Resource.
4022        '''
4023        self.name = name if name is not None else ''
4024        '''
4025         Unique human-readable name of the Resource.
4026        '''
4027        self.password = password if password is not None else ''
4028        '''
4029
4030        '''
4031        self.port = port if port is not None else 0
4032        '''
4033
4034        '''
4035        self.port_override = port_override if port_override is not None else 0
4036        '''
4037
4038        '''
4039        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4040        '''
4041         ID of the secret store containing credentials for this resource, if any.
4042        '''
4043        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4044        '''
4045         Tags is a map of key, value pairs.
4046        '''
4047        self.username = username if username is not None else ''
4048        '''
4049
4050        '''
4051
4052    def __repr__(self):
4053        return '<sdm.DocumentDBHost ' + \
4054            'auth_database: ' + repr(self.auth_database) + ' ' +\
4055            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4056            'healthy: ' + repr(self.healthy) + ' ' +\
4057            'hostname: ' + repr(self.hostname) + ' ' +\
4058            'id: ' + repr(self.id) + ' ' +\
4059            'name: ' + repr(self.name) + ' ' +\
4060            'password: ' + repr(self.password) + ' ' +\
4061            'port: ' + repr(self.port) + ' ' +\
4062            'port_override: ' + repr(self.port_override) + ' ' +\
4063            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4064            'tags: ' + repr(self.tags) + ' ' +\
4065            'username: ' + repr(self.username) + ' ' +\
4066            '>'
4067
4068    def to_dict(self):
4069        return {
4070            'auth_database': self.auth_database,
4071            'egress_filter': self.egress_filter,
4072            'healthy': self.healthy,
4073            'hostname': self.hostname,
4074            'id': self.id,
4075            'name': self.name,
4076            'password': self.password,
4077            'port': self.port,
4078            'port_override': self.port_override,
4079            'secret_store_id': self.secret_store_id,
4080            'tags': self.tags,
4081            'username': self.username,
4082        }
4083
4084    @classmethod
4085    def from_dict(cls, d):
4086        return cls(
4087            auth_database=d.get('auth_database'),
4088            egress_filter=d.get('egress_filter'),
4089            healthy=d.get('healthy'),
4090            hostname=d.get('hostname'),
4091            id=d.get('id'),
4092            name=d.get('name'),
4093            password=d.get('password'),
4094            port=d.get('port'),
4095            port_override=d.get('port_override'),
4096            secret_store_id=d.get('secret_store_id'),
4097            tags=d.get('tags'),
4098            username=d.get('username'),
4099        )
#   DocumentDBHost( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
3988    def __init__(
3989        self,
3990        auth_database=None,
3991        egress_filter=None,
3992        healthy=None,
3993        hostname=None,
3994        id=None,
3995        name=None,
3996        password=None,
3997        port=None,
3998        port_override=None,
3999        secret_store_id=None,
4000        tags=None,
4001        username=None,
4002    ):
4003        self.auth_database = auth_database if auth_database is not None else ''
4004        '''
4005
4006        '''
4007        self.egress_filter = egress_filter if egress_filter is not None else ''
4008        '''
4009         A filter applied to the routing logic to pin datasource to nodes.
4010        '''
4011        self.healthy = healthy if healthy is not None else False
4012        '''
4013         True if the datasource is reachable and the credentials are valid.
4014        '''
4015        self.hostname = hostname if hostname is not None else ''
4016        '''
4017
4018        '''
4019        self.id = id if id is not None else ''
4020        '''
4021         Unique identifier of the Resource.
4022        '''
4023        self.name = name if name is not None else ''
4024        '''
4025         Unique human-readable name of the Resource.
4026        '''
4027        self.password = password if password is not None else ''
4028        '''
4029
4030        '''
4031        self.port = port if port is not None else 0
4032        '''
4033
4034        '''
4035        self.port_override = port_override if port_override is not None else 0
4036        '''
4037
4038        '''
4039        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4040        '''
4041         ID of the secret store containing credentials for this resource, if any.
4042        '''
4043        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4044        '''
4045         Tags is a map of key, value pairs.
4046        '''
4047        self.username = username if username is not None else ''
4048        '''
4049
4050        '''
#   auth_database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
4068    def to_dict(self):
4069        return {
4070            'auth_database': self.auth_database,
4071            'egress_filter': self.egress_filter,
4072            'healthy': self.healthy,
4073            'hostname': self.hostname,
4074            'id': self.id,
4075            'name': self.name,
4076            'password': self.password,
4077            'port': self.port,
4078            'port_override': self.port_override,
4079            'secret_store_id': self.secret_store_id,
4080            'tags': self.tags,
4081            'username': self.username,
4082        }
#  
@classmethod
def from_dict(cls, d):
View Source
4084    @classmethod
4085    def from_dict(cls, d):
4086        return cls(
4087            auth_database=d.get('auth_database'),
4088            egress_filter=d.get('egress_filter'),
4089            healthy=d.get('healthy'),
4090            hostname=d.get('hostname'),
4091            id=d.get('id'),
4092            name=d.get('name'),
4093            password=d.get('password'),
4094            port=d.get('port'),
4095            port_override=d.get('port_override'),
4096            secret_store_id=d.get('secret_store_id'),
4097            tags=d.get('tags'),
4098            username=d.get('username'),
4099        )
#   class DocumentDBReplicaSet:
View Source
4102class DocumentDBReplicaSet:
4103    '''
4104
4105    '''
4106    __slots__ = [
4107        'auth_database',
4108        'connect_to_replica',
4109        'egress_filter',
4110        'healthy',
4111        'hostname',
4112        'id',
4113        'name',
4114        'password',
4115        'port_override',
4116        'replica_set',
4117        'secret_store_id',
4118        'tags',
4119        'username',
4120    ]
4121
4122    def __init__(
4123        self,
4124        auth_database=None,
4125        connect_to_replica=None,
4126        egress_filter=None,
4127        healthy=None,
4128        hostname=None,
4129        id=None,
4130        name=None,
4131        password=None,
4132        port_override=None,
4133        replica_set=None,
4134        secret_store_id=None,
4135        tags=None,
4136        username=None,
4137    ):
4138        self.auth_database = auth_database if auth_database is not None else ''
4139        '''
4140
4141        '''
4142        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4143        '''
4144
4145        '''
4146        self.egress_filter = egress_filter if egress_filter is not None else ''
4147        '''
4148         A filter applied to the routing logic to pin datasource to nodes.
4149        '''
4150        self.healthy = healthy if healthy is not None else False
4151        '''
4152         True if the datasource is reachable and the credentials are valid.
4153        '''
4154        self.hostname = hostname if hostname is not None else ''
4155        '''
4156         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4157        '''
4158        self.id = id if id is not None else ''
4159        '''
4160         Unique identifier of the Resource.
4161        '''
4162        self.name = name if name is not None else ''
4163        '''
4164         Unique human-readable name of the Resource.
4165        '''
4166        self.password = password if password is not None else ''
4167        '''
4168
4169        '''
4170        self.port_override = port_override if port_override is not None else 0
4171        '''
4172
4173        '''
4174        self.replica_set = replica_set if replica_set is not None else ''
4175        '''
4176
4177        '''
4178        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4179        '''
4180         ID of the secret store containing credentials for this resource, if any.
4181        '''
4182        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4183        '''
4184         Tags is a map of key, value pairs.
4185        '''
4186        self.username = username if username is not None else ''
4187        '''
4188
4189        '''
4190
4191    def __repr__(self):
4192        return '<sdm.DocumentDBReplicaSet ' + \
4193            'auth_database: ' + repr(self.auth_database) + ' ' +\
4194            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4195            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4196            'healthy: ' + repr(self.healthy) + ' ' +\
4197            'hostname: ' + repr(self.hostname) + ' ' +\
4198            'id: ' + repr(self.id) + ' ' +\
4199            'name: ' + repr(self.name) + ' ' +\
4200            'password: ' + repr(self.password) + ' ' +\
4201            'port_override: ' + repr(self.port_override) + ' ' +\
4202            'replica_set: ' + repr(self.replica_set) + ' ' +\
4203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4204            'tags: ' + repr(self.tags) + ' ' +\
4205            'username: ' + repr(self.username) + ' ' +\
4206            '>'
4207
4208    def to_dict(self):
4209        return {
4210            'auth_database': self.auth_database,
4211            'connect_to_replica': self.connect_to_replica,
4212            'egress_filter': self.egress_filter,
4213            'healthy': self.healthy,
4214            'hostname': self.hostname,
4215            'id': self.id,
4216            'name': self.name,
4217            'password': self.password,
4218            'port_override': self.port_override,
4219            'replica_set': self.replica_set,
4220            'secret_store_id': self.secret_store_id,
4221            'tags': self.tags,
4222            'username': self.username,
4223        }
4224
4225    @classmethod
4226    def from_dict(cls, d):
4227        return cls(
4228            auth_database=d.get('auth_database'),
4229            connect_to_replica=d.get('connect_to_replica'),
4230            egress_filter=d.get('egress_filter'),
4231            healthy=d.get('healthy'),
4232            hostname=d.get('hostname'),
4233            id=d.get('id'),
4234            name=d.get('name'),
4235            password=d.get('password'),
4236            port_override=d.get('port_override'),
4237            replica_set=d.get('replica_set'),
4238            secret_store_id=d.get('secret_store_id'),
4239            tags=d.get('tags'),
4240            username=d.get('username'),
4241        )
#   DocumentDBReplicaSet( auth_database=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None )
View Source
4122    def __init__(
4123        self,
4124        auth_database=None,
4125        connect_to_replica=None,
4126        egress_filter=None,
4127        healthy=None,
4128        hostname=None,
4129        id=None,
4130        name=None,
4131        password=None,
4132        port_override=None,
4133        replica_set=None,
4134        secret_store_id=None,
4135        tags=None,
4136        username=None,
4137    ):
4138        self.auth_database = auth_database if auth_database is not None else ''
4139        '''
4140
4141        '''
4142        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4143        '''
4144
4145        '''
4146        self.egress_filter = egress_filter if egress_filter is not None else ''
4147        '''
4148         A filter applied to the routing logic to pin datasource to nodes.
4149        '''
4150        self.healthy = healthy if healthy is not None else False
4151        '''
4152         True if the datasource is reachable and the credentials are valid.
4153        '''
4154        self.hostname = hostname if hostname is not None else ''
4155        '''
4156         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4157        '''
4158        self.id = id if id is not None else ''
4159        '''
4160         Unique identifier of the Resource.
4161        '''
4162        self.name = name if name is not None else ''
4163        '''
4164         Unique human-readable name of the Resource.
4165        '''
4166        self.password = password if password is not None else ''
4167        '''
4168
4169        '''
4170        self.port_override = port_override if port_override is not None else 0
4171        '''
4172
4173        '''
4174        self.replica_set = replica_set if replica_set is not None else ''
4175        '''
4176
4177        '''
4178        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4179        '''
4180         ID of the secret store containing credentials for this resource, if any.
4181        '''
4182        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4183        '''
4184         Tags is a map of key, value pairs.
4185        '''
4186        self.username = username if username is not None else ''
4187        '''
4188
4189        '''
#   auth_database
#   connect_to_replica
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port_override
#   replica_set
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
4208    def to_dict(self):
4209        return {
4210            'auth_database': self.auth_database,
4211            'connect_to_replica': self.connect_to_replica,
4212            'egress_filter': self.egress_filter,
4213            'healthy': self.healthy,
4214            'hostname': self.hostname,
4215            'id': self.id,
4216            'name': self.name,
4217            'password': self.password,
4218            'port_override': self.port_override,
4219            'replica_set': self.replica_set,
4220            'secret_store_id': self.secret_store_id,
4221            'tags': self.tags,
4222            'username': self.username,
4223        }
#  
@classmethod
def from_dict(cls, d):
View Source
4225    @classmethod
4226    def from_dict(cls, d):
4227        return cls(
4228            auth_database=d.get('auth_database'),
4229            connect_to_replica=d.get('connect_to_replica'),
4230            egress_filter=d.get('egress_filter'),
4231            healthy=d.get('healthy'),
4232            hostname=d.get('hostname'),
4233            id=d.get('id'),
4234            name=d.get('name'),
4235            password=d.get('password'),
4236            port_override=d.get('port_override'),
4237            replica_set=d.get('replica_set'),
4238            secret_store_id=d.get('secret_store_id'),
4239            tags=d.get('tags'),
4240            username=d.get('username'),
4241        )
#   class Druid:
View Source
4244class Druid:
4245    '''
4246
4247    '''
4248    __slots__ = [
4249        'egress_filter',
4250        'healthy',
4251        'hostname',
4252        'id',
4253        'name',
4254        'password',
4255        'port',
4256        'port_override',
4257        'secret_store_id',
4258        'tags',
4259        'username',
4260    ]
4261
4262    def __init__(
4263        self,
4264        egress_filter=None,
4265        healthy=None,
4266        hostname=None,
4267        id=None,
4268        name=None,
4269        password=None,
4270        port=None,
4271        port_override=None,
4272        secret_store_id=None,
4273        tags=None,
4274        username=None,
4275    ):
4276        self.egress_filter = egress_filter if egress_filter is not None else ''
4277        '''
4278         A filter applied to the routing logic to pin datasource to nodes.
4279        '''
4280        self.healthy = healthy if healthy is not None else False
4281        '''
4282         True if the datasource is reachable and the credentials are valid.
4283        '''
4284        self.hostname = hostname if hostname is not None else ''
4285        '''
4286
4287        '''
4288        self.id = id if id is not None else ''
4289        '''
4290         Unique identifier of the Resource.
4291        '''
4292        self.name = name if name is not None else ''
4293        '''
4294         Unique human-readable name of the Resource.
4295        '''
4296        self.password = password if password is not None else ''
4297        '''
4298
4299        '''
4300        self.port = port if port is not None else 0
4301        '''
4302
4303        '''
4304        self.port_override = port_override if port_override is not None else 0
4305        '''
4306
4307        '''
4308        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4309        '''
4310         ID of the secret store containing credentials for this resource, if any.
4311        '''
4312        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4313        '''
4314         Tags is a map of key, value pairs.
4315        '''
4316        self.username = username if username is not None else ''
4317        '''
4318
4319        '''
4320
4321    def __repr__(self):
4322        return '<sdm.Druid ' + \
4323            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4324            'healthy: ' + repr(self.healthy) + ' ' +\
4325            'hostname: ' + repr(self.hostname) + ' ' +\
4326            'id: ' + repr(self.id) + ' ' +\
4327            'name: ' + repr(self.name) + ' ' +\
4328            'password: ' + repr(self.password) + ' ' +\
4329            'port: ' + repr(self.port) + ' ' +\
4330            'port_override: ' + repr(self.port_override) + ' ' +\
4331            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4332            'tags: ' + repr(self.tags) + ' ' +\
4333            'username: ' + repr(self.username) + ' ' +\
4334            '>'
4335
4336    def to_dict(self):
4337        return {
4338            'egress_filter': self.egress_filter,
4339            'healthy': self.healthy,
4340            'hostname': self.hostname,
4341            'id': self.id,
4342            'name': self.name,
4343            'password': self.password,
4344            'port': self.port,
4345            'port_override': self.port_override,
4346            'secret_store_id': self.secret_store_id,
4347            'tags': self.tags,
4348            'username': self.username,
4349        }
4350
4351    @classmethod
4352    def from_dict(cls, d):
4353        return cls(
4354            egress_filter=d.get('egress_filter'),
4355            healthy=d.get('healthy'),
4356            hostname=d.get('hostname'),
4357            id=d.get('id'),
4358            name=d.get('name'),
4359            password=d.get('password'),
4360            port=d.get('port'),
4361            port_override=d.get('port_override'),
4362            secret_store_id=d.get('secret_store_id'),
4363            tags=d.get('tags'),
4364            username=d.get('username'),
4365        )
#   Druid( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
4262    def __init__(
4263        self,
4264        egress_filter=None,
4265        healthy=None,
4266        hostname=None,
4267        id=None,
4268        name=None,
4269        password=None,
4270        port=None,
4271        port_override=None,
4272        secret_store_id=None,
4273        tags=None,
4274        username=None,
4275    ):
4276        self.egress_filter = egress_filter if egress_filter is not None else ''
4277        '''
4278         A filter applied to the routing logic to pin datasource to nodes.
4279        '''
4280        self.healthy = healthy if healthy is not None else False
4281        '''
4282         True if the datasource is reachable and the credentials are valid.
4283        '''
4284        self.hostname = hostname if hostname is not None else ''
4285        '''
4286
4287        '''
4288        self.id = id if id is not None else ''
4289        '''
4290         Unique identifier of the Resource.
4291        '''
4292        self.name = name if name is not None else ''
4293        '''
4294         Unique human-readable name of the Resource.
4295        '''
4296        self.password = password if password is not None else ''
4297        '''
4298
4299        '''
4300        self.port = port if port is not None else 0
4301        '''
4302
4303        '''
4304        self.port_override = port_override if port_override is not None else 0
4305        '''
4306
4307        '''
4308        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4309        '''
4310         ID of the secret store containing credentials for this resource, if any.
4311        '''
4312        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4313        '''
4314         Tags is a map of key, value pairs.
4315        '''
4316        self.username = username if username is not None else ''
4317        '''
4318
4319        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
4336    def to_dict(self):
4337        return {
4338            'egress_filter': self.egress_filter,
4339            'healthy': self.healthy,
4340            'hostname': self.hostname,
4341            'id': self.id,
4342            'name': self.name,
4343            'password': self.password,
4344            'port': self.port,
4345            'port_override': self.port_override,
4346            'secret_store_id': self.secret_store_id,
4347            'tags': self.tags,
4348            'username': self.username,
4349        }
#  
@classmethod
def from_dict(cls, d):
View Source
4351    @classmethod
4352    def from_dict(cls, d):
4353        return cls(
4354            egress_filter=d.get('egress_filter'),
4355            healthy=d.get('healthy'),
4356            hostname=d.get('hostname'),
4357            id=d.get('id'),
4358            name=d.get('name'),
4359            password=d.get('password'),
4360            port=d.get('port'),
4361            port_override=d.get('port_override'),
4362            secret_store_id=d.get('secret_store_id'),
4363            tags=d.get('tags'),
4364            username=d.get('username'),
4365        )
#   class DynamoDB:
View Source
4368class DynamoDB:
4369    '''
4370
4371    '''
4372    __slots__ = [
4373        'access_key',
4374        'egress_filter',
4375        'endpoint',
4376        'healthy',
4377        'id',
4378        'name',
4379        'port_override',
4380        'region',
4381        'role_arn',
4382        'role_external_id',
4383        'secret_access_key',
4384        'secret_store_id',
4385        'tags',
4386    ]
4387
4388    def __init__(
4389        self,
4390        access_key=None,
4391        egress_filter=None,
4392        endpoint=None,
4393        healthy=None,
4394        id=None,
4395        name=None,
4396        port_override=None,
4397        region=None,
4398        role_arn=None,
4399        role_external_id=None,
4400        secret_access_key=None,
4401        secret_store_id=None,
4402        tags=None,
4403    ):
4404        self.access_key = access_key if access_key is not None else ''
4405        '''
4406
4407        '''
4408        self.egress_filter = egress_filter if egress_filter is not None else ''
4409        '''
4410         A filter applied to the routing logic to pin datasource to nodes.
4411        '''
4412        self.endpoint = endpoint if endpoint is not None else ''
4413        '''
4414
4415        '''
4416        self.healthy = healthy if healthy is not None else False
4417        '''
4418         True if the datasource is reachable and the credentials are valid.
4419        '''
4420        self.id = id if id is not None else ''
4421        '''
4422         Unique identifier of the Resource.
4423        '''
4424        self.name = name if name is not None else ''
4425        '''
4426         Unique human-readable name of the Resource.
4427        '''
4428        self.port_override = port_override if port_override is not None else 0
4429        '''
4430
4431        '''
4432        self.region = region if region is not None else ''
4433        '''
4434
4435        '''
4436        self.role_arn = role_arn if role_arn is not None else ''
4437        '''
4438
4439        '''
4440        self.role_external_id = role_external_id if role_external_id is not None else ''
4441        '''
4442
4443        '''
4444        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4445        '''
4446
4447        '''
4448        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4449        '''
4450         ID of the secret store containing credentials for this resource, if any.
4451        '''
4452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4453        '''
4454         Tags is a map of key, value pairs.
4455        '''
4456
4457    def __repr__(self):
4458        return '<sdm.DynamoDB ' + \
4459            'access_key: ' + repr(self.access_key) + ' ' +\
4460            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4461            'endpoint: ' + repr(self.endpoint) + ' ' +\
4462            'healthy: ' + repr(self.healthy) + ' ' +\
4463            'id: ' + repr(self.id) + ' ' +\
4464            'name: ' + repr(self.name) + ' ' +\
4465            'port_override: ' + repr(self.port_override) + ' ' +\
4466            'region: ' + repr(self.region) + ' ' +\
4467            'role_arn: ' + repr(self.role_arn) + ' ' +\
4468            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4469            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4470            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4471            'tags: ' + repr(self.tags) + ' ' +\
4472            '>'
4473
4474    def to_dict(self):
4475        return {
4476            'access_key': self.access_key,
4477            'egress_filter': self.egress_filter,
4478            'endpoint': self.endpoint,
4479            'healthy': self.healthy,
4480            'id': self.id,
4481            'name': self.name,
4482            'port_override': self.port_override,
4483            'region': self.region,
4484            'role_arn': self.role_arn,
4485            'role_external_id': self.role_external_id,
4486            'secret_access_key': self.secret_access_key,
4487            'secret_store_id': self.secret_store_id,
4488            'tags': self.tags,
4489        }
4490
4491    @classmethod
4492    def from_dict(cls, d):
4493        return cls(
4494            access_key=d.get('access_key'),
4495            egress_filter=d.get('egress_filter'),
4496            endpoint=d.get('endpoint'),
4497            healthy=d.get('healthy'),
4498            id=d.get('id'),
4499            name=d.get('name'),
4500            port_override=d.get('port_override'),
4501            region=d.get('region'),
4502            role_arn=d.get('role_arn'),
4503            role_external_id=d.get('role_external_id'),
4504            secret_access_key=d.get('secret_access_key'),
4505            secret_store_id=d.get('secret_store_id'),
4506            tags=d.get('tags'),
4507        )
#   DynamoDB( access_key=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
4388    def __init__(
4389        self,
4390        access_key=None,
4391        egress_filter=None,
4392        endpoint=None,
4393        healthy=None,
4394        id=None,
4395        name=None,
4396        port_override=None,
4397        region=None,
4398        role_arn=None,
4399        role_external_id=None,
4400        secret_access_key=None,
4401        secret_store_id=None,
4402        tags=None,
4403    ):
4404        self.access_key = access_key if access_key is not None else ''
4405        '''
4406
4407        '''
4408        self.egress_filter = egress_filter if egress_filter is not None else ''
4409        '''
4410         A filter applied to the routing logic to pin datasource to nodes.
4411        '''
4412        self.endpoint = endpoint if endpoint is not None else ''
4413        '''
4414
4415        '''
4416        self.healthy = healthy if healthy is not None else False
4417        '''
4418         True if the datasource is reachable and the credentials are valid.
4419        '''
4420        self.id = id if id is not None else ''
4421        '''
4422         Unique identifier of the Resource.
4423        '''
4424        self.name = name if name is not None else ''
4425        '''
4426         Unique human-readable name of the Resource.
4427        '''
4428        self.port_override = port_override if port_override is not None else 0
4429        '''
4430
4431        '''
4432        self.region = region if region is not None else ''
4433        '''
4434
4435        '''
4436        self.role_arn = role_arn if role_arn is not None else ''
4437        '''
4438
4439        '''
4440        self.role_external_id = role_external_id if role_external_id is not None else ''
4441        '''
4442
4443        '''
4444        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4445        '''
4446
4447        '''
4448        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4449        '''
4450         ID of the secret store containing credentials for this resource, if any.
4451        '''
4452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4453        '''
4454         Tags is a map of key, value pairs.
4455        '''
#   access_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
4474    def to_dict(self):
4475        return {
4476            'access_key': self.access_key,
4477            'egress_filter': self.egress_filter,
4478            'endpoint': self.endpoint,
4479            'healthy': self.healthy,
4480            'id': self.id,
4481            'name': self.name,
4482            'port_override': self.port_override,
4483            'region': self.region,
4484            'role_arn': self.role_arn,
4485            'role_external_id': self.role_external_id,
4486            'secret_access_key': self.secret_access_key,
4487            'secret_store_id': self.secret_store_id,
4488            'tags': self.tags,
4489        }
#  
@classmethod
def from_dict(cls, d):
View Source
4491    @classmethod
4492    def from_dict(cls, d):
4493        return cls(
4494            access_key=d.get('access_key'),
4495            egress_filter=d.get('egress_filter'),
4496            endpoint=d.get('endpoint'),
4497            healthy=d.get('healthy'),
4498            id=d.get('id'),
4499            name=d.get('name'),
4500            port_override=d.get('port_override'),
4501            region=d.get('region'),
4502            role_arn=d.get('role_arn'),
4503            role_external_id=d.get('role_external_id'),
4504            secret_access_key=d.get('secret_access_key'),
4505            secret_store_id=d.get('secret_store_id'),
4506            tags=d.get('tags'),
4507        )
#   class Elastic:
View Source
4510class Elastic:
4511    '''
4512
4513    '''
4514    __slots__ = [
4515        'egress_filter',
4516        'healthy',
4517        'hostname',
4518        'id',
4519        'name',
4520        'password',
4521        'port',
4522        'port_override',
4523        'secret_store_id',
4524        'tags',
4525        'tls_required',
4526        'username',
4527    ]
4528
4529    def __init__(
4530        self,
4531        egress_filter=None,
4532        healthy=None,
4533        hostname=None,
4534        id=None,
4535        name=None,
4536        password=None,
4537        port=None,
4538        port_override=None,
4539        secret_store_id=None,
4540        tags=None,
4541        tls_required=None,
4542        username=None,
4543    ):
4544        self.egress_filter = egress_filter if egress_filter is not None else ''
4545        '''
4546         A filter applied to the routing logic to pin datasource to nodes.
4547        '''
4548        self.healthy = healthy if healthy is not None else False
4549        '''
4550         True if the datasource is reachable and the credentials are valid.
4551        '''
4552        self.hostname = hostname if hostname is not None else ''
4553        '''
4554
4555        '''
4556        self.id = id if id is not None else ''
4557        '''
4558         Unique identifier of the Resource.
4559        '''
4560        self.name = name if name is not None else ''
4561        '''
4562         Unique human-readable name of the Resource.
4563        '''
4564        self.password = password if password is not None else ''
4565        '''
4566
4567        '''
4568        self.port = port if port is not None else 0
4569        '''
4570
4571        '''
4572        self.port_override = port_override if port_override is not None else 0
4573        '''
4574
4575        '''
4576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4577        '''
4578         ID of the secret store containing credentials for this resource, if any.
4579        '''
4580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4581        '''
4582         Tags is a map of key, value pairs.
4583        '''
4584        self.tls_required = tls_required if tls_required is not None else False
4585        '''
4586
4587        '''
4588        self.username = username if username is not None else ''
4589        '''
4590
4591        '''
4592
4593    def __repr__(self):
4594        return '<sdm.Elastic ' + \
4595            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4596            'healthy: ' + repr(self.healthy) + ' ' +\
4597            'hostname: ' + repr(self.hostname) + ' ' +\
4598            'id: ' + repr(self.id) + ' ' +\
4599            'name: ' + repr(self.name) + ' ' +\
4600            'password: ' + repr(self.password) + ' ' +\
4601            'port: ' + repr(self.port) + ' ' +\
4602            'port_override: ' + repr(self.port_override) + ' ' +\
4603            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4604            'tags: ' + repr(self.tags) + ' ' +\
4605            'tls_required: ' + repr(self.tls_required) + ' ' +\
4606            'username: ' + repr(self.username) + ' ' +\
4607            '>'
4608
4609    def to_dict(self):
4610        return {
4611            'egress_filter': self.egress_filter,
4612            'healthy': self.healthy,
4613            'hostname': self.hostname,
4614            'id': self.id,
4615            'name': self.name,
4616            'password': self.password,
4617            'port': self.port,
4618            'port_override': self.port_override,
4619            'secret_store_id': self.secret_store_id,
4620            'tags': self.tags,
4621            'tls_required': self.tls_required,
4622            'username': self.username,
4623        }
4624
4625    @classmethod
4626    def from_dict(cls, d):
4627        return cls(
4628            egress_filter=d.get('egress_filter'),
4629            healthy=d.get('healthy'),
4630            hostname=d.get('hostname'),
4631            id=d.get('id'),
4632            name=d.get('name'),
4633            password=d.get('password'),
4634            port=d.get('port'),
4635            port_override=d.get('port_override'),
4636            secret_store_id=d.get('secret_store_id'),
4637            tags=d.get('tags'),
4638            tls_required=d.get('tls_required'),
4639            username=d.get('username'),
4640        )
#   Elastic( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
4529    def __init__(
4530        self,
4531        egress_filter=None,
4532        healthy=None,
4533        hostname=None,
4534        id=None,
4535        name=None,
4536        password=None,
4537        port=None,
4538        port_override=None,
4539        secret_store_id=None,
4540        tags=None,
4541        tls_required=None,
4542        username=None,
4543    ):
4544        self.egress_filter = egress_filter if egress_filter is not None else ''
4545        '''
4546         A filter applied to the routing logic to pin datasource to nodes.
4547        '''
4548        self.healthy = healthy if healthy is not None else False
4549        '''
4550         True if the datasource is reachable and the credentials are valid.
4551        '''
4552        self.hostname = hostname if hostname is not None else ''
4553        '''
4554
4555        '''
4556        self.id = id if id is not None else ''
4557        '''
4558         Unique identifier of the Resource.
4559        '''
4560        self.name = name if name is not None else ''
4561        '''
4562         Unique human-readable name of the Resource.
4563        '''
4564        self.password = password if password is not None else ''
4565        '''
4566
4567        '''
4568        self.port = port if port is not None else 0
4569        '''
4570
4571        '''
4572        self.port_override = port_override if port_override is not None else 0
4573        '''
4574
4575        '''
4576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4577        '''
4578         ID of the secret store containing credentials for this resource, if any.
4579        '''
4580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4581        '''
4582         Tags is a map of key, value pairs.
4583        '''
4584        self.tls_required = tls_required if tls_required is not None else False
4585        '''
4586
4587        '''
4588        self.username = username if username is not None else ''
4589        '''
4590
4591        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
4609    def to_dict(self):
4610        return {
4611            'egress_filter': self.egress_filter,
4612            'healthy': self.healthy,
4613            'hostname': self.hostname,
4614            'id': self.id,
4615            'name': self.name,
4616            'password': self.password,
4617            'port': self.port,
4618            'port_override': self.port_override,
4619            'secret_store_id': self.secret_store_id,
4620            'tags': self.tags,
4621            'tls_required': self.tls_required,
4622            'username': self.username,
4623        }
#  
@classmethod
def from_dict(cls, d):
View Source
4625    @classmethod
4626    def from_dict(cls, d):
4627        return cls(
4628            egress_filter=d.get('egress_filter'),
4629            healthy=d.get('healthy'),
4630            hostname=d.get('hostname'),
4631            id=d.get('id'),
4632            name=d.get('name'),
4633            password=d.get('password'),
4634            port=d.get('port'),
4635            port_override=d.get('port_override'),
4636            secret_store_id=d.get('secret_store_id'),
4637            tags=d.get('tags'),
4638            tls_required=d.get('tls_required'),
4639            username=d.get('username'),
4640        )
#   class ElasticacheRedis:
View Source
4643class ElasticacheRedis:
4644    '''
4645
4646    '''
4647    __slots__ = [
4648        'egress_filter',
4649        'healthy',
4650        'hostname',
4651        'id',
4652        'name',
4653        'password',
4654        'port',
4655        'port_override',
4656        'secret_store_id',
4657        'tags',
4658        'tls_required',
4659    ]
4660
4661    def __init__(
4662        self,
4663        egress_filter=None,
4664        healthy=None,
4665        hostname=None,
4666        id=None,
4667        name=None,
4668        password=None,
4669        port=None,
4670        port_override=None,
4671        secret_store_id=None,
4672        tags=None,
4673        tls_required=None,
4674    ):
4675        self.egress_filter = egress_filter if egress_filter is not None else ''
4676        '''
4677         A filter applied to the routing logic to pin datasource to nodes.
4678        '''
4679        self.healthy = healthy if healthy is not None else False
4680        '''
4681         True if the datasource is reachable and the credentials are valid.
4682        '''
4683        self.hostname = hostname if hostname is not None else ''
4684        '''
4685
4686        '''
4687        self.id = id if id is not None else ''
4688        '''
4689         Unique identifier of the Resource.
4690        '''
4691        self.name = name if name is not None else ''
4692        '''
4693         Unique human-readable name of the Resource.
4694        '''
4695        self.password = password if password is not None else ''
4696        '''
4697
4698        '''
4699        self.port = port if port is not None else 0
4700        '''
4701
4702        '''
4703        self.port_override = port_override if port_override is not None else 0
4704        '''
4705
4706        '''
4707        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4708        '''
4709         ID of the secret store containing credentials for this resource, if any.
4710        '''
4711        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4712        '''
4713         Tags is a map of key, value pairs.
4714        '''
4715        self.tls_required = tls_required if tls_required is not None else False
4716        '''
4717
4718        '''
4719
4720    def __repr__(self):
4721        return '<sdm.ElasticacheRedis ' + \
4722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4723            'healthy: ' + repr(self.healthy) + ' ' +\
4724            'hostname: ' + repr(self.hostname) + ' ' +\
4725            'id: ' + repr(self.id) + ' ' +\
4726            'name: ' + repr(self.name) + ' ' +\
4727            'password: ' + repr(self.password) + ' ' +\
4728            'port: ' + repr(self.port) + ' ' +\
4729            'port_override: ' + repr(self.port_override) + ' ' +\
4730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4731            'tags: ' + repr(self.tags) + ' ' +\
4732            'tls_required: ' + repr(self.tls_required) + ' ' +\
4733            '>'
4734
4735    def to_dict(self):
4736        return {
4737            'egress_filter': self.egress_filter,
4738            'healthy': self.healthy,
4739            'hostname': self.hostname,
4740            'id': self.id,
4741            'name': self.name,
4742            'password': self.password,
4743            'port': self.port,
4744            'port_override': self.port_override,
4745            'secret_store_id': self.secret_store_id,
4746            'tags': self.tags,
4747            'tls_required': self.tls_required,
4748        }
4749
4750    @classmethod
4751    def from_dict(cls, d):
4752        return cls(
4753            egress_filter=d.get('egress_filter'),
4754            healthy=d.get('healthy'),
4755            hostname=d.get('hostname'),
4756            id=d.get('id'),
4757            name=d.get('name'),
4758            password=d.get('password'),
4759            port=d.get('port'),
4760            port_override=d.get('port_override'),
4761            secret_store_id=d.get('secret_store_id'),
4762            tags=d.get('tags'),
4763            tls_required=d.get('tls_required'),
4764        )
#   ElasticacheRedis( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None )
View Source
4661    def __init__(
4662        self,
4663        egress_filter=None,
4664        healthy=None,
4665        hostname=None,
4666        id=None,
4667        name=None,
4668        password=None,
4669        port=None,
4670        port_override=None,
4671        secret_store_id=None,
4672        tags=None,
4673        tls_required=None,
4674    ):
4675        self.egress_filter = egress_filter if egress_filter is not None else ''
4676        '''
4677         A filter applied to the routing logic to pin datasource to nodes.
4678        '''
4679        self.healthy = healthy if healthy is not None else False
4680        '''
4681         True if the datasource is reachable and the credentials are valid.
4682        '''
4683        self.hostname = hostname if hostname is not None else ''
4684        '''
4685
4686        '''
4687        self.id = id if id is not None else ''
4688        '''
4689         Unique identifier of the Resource.
4690        '''
4691        self.name = name if name is not None else ''
4692        '''
4693         Unique human-readable name of the Resource.
4694        '''
4695        self.password = password if password is not None else ''
4696        '''
4697
4698        '''
4699        self.port = port if port is not None else 0
4700        '''
4701
4702        '''
4703        self.port_override = port_override if port_override is not None else 0
4704        '''
4705
4706        '''
4707        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4708        '''
4709         ID of the secret store containing credentials for this resource, if any.
4710        '''
4711        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4712        '''
4713         Tags is a map of key, value pairs.
4714        '''
4715        self.tls_required = tls_required if tls_required is not None else False
4716        '''
4717
4718        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   def to_dict(self):
View Source
4735    def to_dict(self):
4736        return {
4737            'egress_filter': self.egress_filter,
4738            'healthy': self.healthy,
4739            'hostname': self.hostname,
4740            'id': self.id,
4741            'name': self.name,
4742            'password': self.password,
4743            'port': self.port,
4744            'port_override': self.port_override,
4745            'secret_store_id': self.secret_store_id,
4746            'tags': self.tags,
4747            'tls_required': self.tls_required,
4748        }
#  
@classmethod
def from_dict(cls, d):
View Source
4750    @classmethod
4751    def from_dict(cls, d):
4752        return cls(
4753            egress_filter=d.get('egress_filter'),
4754            healthy=d.get('healthy'),
4755            hostname=d.get('hostname'),
4756            id=d.get('id'),
4757            name=d.get('name'),
4758            password=d.get('password'),
4759            port=d.get('port'),
4760            port_override=d.get('port_override'),
4761            secret_store_id=d.get('secret_store_id'),
4762            tags=d.get('tags'),
4763            tls_required=d.get('tls_required'),
4764        )
#   class GCP:
View Source
4767class GCP:
4768    '''
4769
4770    '''
4771    __slots__ = [
4772        'egress_filter',
4773        'healthy',
4774        'id',
4775        'keyfile',
4776        'name',
4777        'scopes',
4778        'secret_store_id',
4779        'tags',
4780    ]
4781
4782    def __init__(
4783        self,
4784        egress_filter=None,
4785        healthy=None,
4786        id=None,
4787        keyfile=None,
4788        name=None,
4789        scopes=None,
4790        secret_store_id=None,
4791        tags=None,
4792    ):
4793        self.egress_filter = egress_filter if egress_filter is not None else ''
4794        '''
4795         A filter applied to the routing logic to pin datasource to nodes.
4796        '''
4797        self.healthy = healthy if healthy is not None else False
4798        '''
4799         True if the datasource is reachable and the credentials are valid.
4800        '''
4801        self.id = id if id is not None else ''
4802        '''
4803         Unique identifier of the Resource.
4804        '''
4805        self.keyfile = keyfile if keyfile is not None else ''
4806        '''
4807
4808        '''
4809        self.name = name if name is not None else ''
4810        '''
4811         Unique human-readable name of the Resource.
4812        '''
4813        self.scopes = scopes if scopes is not None else ''
4814        '''
4815
4816        '''
4817        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4818        '''
4819         ID of the secret store containing credentials for this resource, if any.
4820        '''
4821        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4822        '''
4823         Tags is a map of key, value pairs.
4824        '''
4825
4826    def __repr__(self):
4827        return '<sdm.GCP ' + \
4828            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4829            'healthy: ' + repr(self.healthy) + ' ' +\
4830            'id: ' + repr(self.id) + ' ' +\
4831            'keyfile: ' + repr(self.keyfile) + ' ' +\
4832            'name: ' + repr(self.name) + ' ' +\
4833            'scopes: ' + repr(self.scopes) + ' ' +\
4834            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4835            'tags: ' + repr(self.tags) + ' ' +\
4836            '>'
4837
4838    def to_dict(self):
4839        return {
4840            'egress_filter': self.egress_filter,
4841            'healthy': self.healthy,
4842            'id': self.id,
4843            'keyfile': self.keyfile,
4844            'name': self.name,
4845            'scopes': self.scopes,
4846            'secret_store_id': self.secret_store_id,
4847            'tags': self.tags,
4848        }
4849
4850    @classmethod
4851    def from_dict(cls, d):
4852        return cls(
4853            egress_filter=d.get('egress_filter'),
4854            healthy=d.get('healthy'),
4855            id=d.get('id'),
4856            keyfile=d.get('keyfile'),
4857            name=d.get('name'),
4858            scopes=d.get('scopes'),
4859            secret_store_id=d.get('secret_store_id'),
4860            tags=d.get('tags'),
4861        )
#   GCP( egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None )
View Source
4782    def __init__(
4783        self,
4784        egress_filter=None,
4785        healthy=None,
4786        id=None,
4787        keyfile=None,
4788        name=None,
4789        scopes=None,
4790        secret_store_id=None,
4791        tags=None,
4792    ):
4793        self.egress_filter = egress_filter if egress_filter is not None else ''
4794        '''
4795         A filter applied to the routing logic to pin datasource to nodes.
4796        '''
4797        self.healthy = healthy if healthy is not None else False
4798        '''
4799         True if the datasource is reachable and the credentials are valid.
4800        '''
4801        self.id = id if id is not None else ''
4802        '''
4803         Unique identifier of the Resource.
4804        '''
4805        self.keyfile = keyfile if keyfile is not None else ''
4806        '''
4807
4808        '''
4809        self.name = name if name is not None else ''
4810        '''
4811         Unique human-readable name of the Resource.
4812        '''
4813        self.scopes = scopes if scopes is not None else ''
4814        '''
4815
4816        '''
4817        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4818        '''
4819         ID of the secret store containing credentials for this resource, if any.
4820        '''
4821        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4822        '''
4823         Tags is a map of key, value pairs.
4824        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   keyfile
#   name

Unique human-readable name of the Resource.

#   scopes
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
4838    def to_dict(self):
4839        return {
4840            'egress_filter': self.egress_filter,
4841            'healthy': self.healthy,
4842            'id': self.id,
4843            'keyfile': self.keyfile,
4844            'name': self.name,
4845            'scopes': self.scopes,
4846            'secret_store_id': self.secret_store_id,
4847            'tags': self.tags,
4848        }
#  
@classmethod
def from_dict(cls, d):
View Source
4850    @classmethod
4851    def from_dict(cls, d):
4852        return cls(
4853            egress_filter=d.get('egress_filter'),
4854            healthy=d.get('healthy'),
4855            id=d.get('id'),
4856            keyfile=d.get('keyfile'),
4857            name=d.get('name'),
4858            scopes=d.get('scopes'),
4859            secret_store_id=d.get('secret_store_id'),
4860            tags=d.get('tags'),
4861        )
#   class GCPStore:
View Source
4864class GCPStore:
4865    '''
4866
4867    '''
4868    __slots__ = [
4869        'id',
4870        'name',
4871        'projectid',
4872        'tags',
4873    ]
4874
4875    def __init__(
4876        self,
4877        id=None,
4878        name=None,
4879        projectid=None,
4880        tags=None,
4881    ):
4882        self.id = id if id is not None else ''
4883        '''
4884         Unique identifier of the SecretStore.
4885        '''
4886        self.name = name if name is not None else ''
4887        '''
4888         Unique human-readable name of the SecretStore.
4889        '''
4890        self.projectid = projectid if projectid is not None else ''
4891        '''
4892
4893        '''
4894        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4895        '''
4896         Tags is a map of key, value pairs.
4897        '''
4898
4899    def __repr__(self):
4900        return '<sdm.GCPStore ' + \
4901            'id: ' + repr(self.id) + ' ' +\
4902            'name: ' + repr(self.name) + ' ' +\
4903            'projectid: ' + repr(self.projectid) + ' ' +\
4904            'tags: ' + repr(self.tags) + ' ' +\
4905            '>'
4906
4907    def to_dict(self):
4908        return {
4909            'id': self.id,
4910            'name': self.name,
4911            'projectid': self.projectid,
4912            'tags': self.tags,
4913        }
4914
4915    @classmethod
4916    def from_dict(cls, d):
4917        return cls(
4918            id=d.get('id'),
4919            name=d.get('name'),
4920            projectid=d.get('projectid'),
4921            tags=d.get('tags'),
4922        )
#   GCPStore(id=None, name=None, projectid=None, tags=None)
View Source
4875    def __init__(
4876        self,
4877        id=None,
4878        name=None,
4879        projectid=None,
4880        tags=None,
4881    ):
4882        self.id = id if id is not None else ''
4883        '''
4884         Unique identifier of the SecretStore.
4885        '''
4886        self.name = name if name is not None else ''
4887        '''
4888         Unique human-readable name of the SecretStore.
4889        '''
4890        self.projectid = projectid if projectid is not None else ''
4891        '''
4892
4893        '''
4894        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4895        '''
4896         Tags is a map of key, value pairs.
4897        '''
#   id

Unique identifier of the SecretStore.

#   name

Unique human-readable name of the SecretStore.

#   projectid
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
4907    def to_dict(self):
4908        return {
4909            'id': self.id,
4910            'name': self.name,
4911            'projectid': self.projectid,
4912            'tags': self.tags,
4913        }
#  
@classmethod
def from_dict(cls, d):
View Source
4915    @classmethod
4916    def from_dict(cls, d):
4917        return cls(
4918            id=d.get('id'),
4919            name=d.get('name'),
4920            projectid=d.get('projectid'),
4921            tags=d.get('tags'),
4922        )
#   class Gateway:
View Source
4925class Gateway:
4926    '''
4927     Gateway represents a StrongDM CLI installation running in gateway mode.
4928    '''
4929    __slots__ = [
4930        'bind_address',
4931        'gateway_filter',
4932        'id',
4933        'listen_address',
4934        'name',
4935        'state',
4936        'tags',
4937    ]
4938
4939    def __init__(
4940        self,
4941        bind_address=None,
4942        gateway_filter=None,
4943        id=None,
4944        listen_address=None,
4945        name=None,
4946        state=None,
4947        tags=None,
4948    ):
4949        self.bind_address = bind_address if bind_address is not None else ''
4950        '''
4951         The hostname/port tuple which the gateway daemon will bind to.
4952         If not provided on create, set to "0.0.0.0:listen_address_port".
4953        '''
4954        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
4955        '''
4956         GatewayFilter can be used to restrict the peering between relays and
4957         gateways.
4958        '''
4959        self.id = id if id is not None else ''
4960        '''
4961         Unique identifier of the Gateway.
4962        '''
4963        self.listen_address = listen_address if listen_address is not None else ''
4964        '''
4965         The public hostname/port tuple at which the gateway will be accessible to clients.
4966        '''
4967        self.name = name if name is not None else ''
4968        '''
4969         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
4970        '''
4971        self.state = state if state is not None else ''
4972        '''
4973         The current state of the gateway. One of: "new", "verifying_restart",
4974         "restarting", "started", "stopped", "dead", "unknown"
4975        '''
4976        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4977        '''
4978         Tags is a map of key, value pairs.
4979        '''
4980
4981    def __repr__(self):
4982        return '<sdm.Gateway ' + \
4983            'bind_address: ' + repr(self.bind_address) + ' ' +\
4984            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
4985            'id: ' + repr(self.id) + ' ' +\
4986            'listen_address: ' + repr(self.listen_address) + ' ' +\
4987            'name: ' + repr(self.name) + ' ' +\
4988            'state: ' + repr(self.state) + ' ' +\
4989            'tags: ' + repr(self.tags) + ' ' +\
4990            '>'
4991
4992    def to_dict(self):
4993        return {
4994            'bind_address': self.bind_address,
4995            'gateway_filter': self.gateway_filter,
4996            'id': self.id,
4997            'listen_address': self.listen_address,
4998            'name': self.name,
4999            'state': self.state,
5000            'tags': self.tags,
5001        }
5002
5003    @classmethod
5004    def from_dict(cls, d):
5005        return cls(
5006            bind_address=d.get('bind_address'),
5007            gateway_filter=d.get('gateway_filter'),
5008            id=d.get('id'),
5009            listen_address=d.get('listen_address'),
5010            name=d.get('name'),
5011            state=d.get('state'),
5012            tags=d.get('tags'),
5013        )

Gateway represents a StrongDM CLI installation running in gateway mode.

#   Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None )
View Source
4939    def __init__(
4940        self,
4941        bind_address=None,
4942        gateway_filter=None,
4943        id=None,
4944        listen_address=None,
4945        name=None,
4946        state=None,
4947        tags=None,
4948    ):
4949        self.bind_address = bind_address if bind_address is not None else ''
4950        '''
4951         The hostname/port tuple which the gateway daemon will bind to.
4952         If not provided on create, set to "0.0.0.0:listen_address_port".
4953        '''
4954        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
4955        '''
4956         GatewayFilter can be used to restrict the peering between relays and
4957         gateways.
4958        '''
4959        self.id = id if id is not None else ''
4960        '''
4961         Unique identifier of the Gateway.
4962        '''
4963        self.listen_address = listen_address if listen_address is not None else ''
4964        '''
4965         The public hostname/port tuple at which the gateway will be accessible to clients.
4966        '''
4967        self.name = name if name is not None else ''
4968        '''
4969         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
4970        '''
4971        self.state = state if state is not None else ''
4972        '''
4973         The current state of the gateway. One of: "new", "verifying_restart",
4974         "restarting", "started", "stopped", "dead", "unknown"
4975        '''
4976        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4977        '''
4978         Tags is a map of key, value pairs.
4979        '''
#   bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

#   gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

#   id

Unique identifier of the Gateway.

#   listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

#   name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

#   state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
4992    def to_dict(self):
4993        return {
4994            'bind_address': self.bind_address,
4995            'gateway_filter': self.gateway_filter,
4996            'id': self.id,
4997            'listen_address': self.listen_address,
4998            'name': self.name,
4999            'state': self.state,
5000            'tags': self.tags,
5001        }
#  
@classmethod
def from_dict(cls, d):
View Source
5003    @classmethod
5004    def from_dict(cls, d):
5005        return cls(
5006            bind_address=d.get('bind_address'),
5007            gateway_filter=d.get('gateway_filter'),
5008            id=d.get('id'),
5009            listen_address=d.get('listen_address'),
5010            name=d.get('name'),
5011            state=d.get('state'),
5012            tags=d.get('tags'),
5013        )
#   class GetResponseMetadata:
View Source
5016class GetResponseMetadata:
5017    '''
5018     GetResponseMetadata is reserved for future use.
5019    '''
5020    __slots__ = []
5021
5022    def __init__(self, ):
5023        pass
5024
5025    def __repr__(self):
5026        return '<sdm.GetResponseMetadata ' + \
5027            '>'
5028
5029    def to_dict(self):
5030        return {}
5031
5032    @classmethod
5033    def from_dict(cls, d):
5034        return cls()

GetResponseMetadata is reserved for future use.

#   GetResponseMetadata()
View Source
5022    def __init__(self, ):
5023        pass
#   def to_dict(self):
View Source
5029    def to_dict(self):
5030        return {}
#  
@classmethod
def from_dict(cls, d):
View Source
5032    @classmethod
5033    def from_dict(cls, d):
5034        return cls()
#   class GoogleGKE:
View Source
5037class GoogleGKE:
5038    '''
5039
5040    '''
5041    __slots__ = [
5042        'certificate_authority',
5043        'egress_filter',
5044        'endpoint',
5045        'healthcheck_namespace',
5046        'healthy',
5047        'id',
5048        'name',
5049        'secret_store_id',
5050        'service_account_key',
5051        'tags',
5052    ]
5053
5054    def __init__(
5055        self,
5056        certificate_authority=None,
5057        egress_filter=None,
5058        endpoint=None,
5059        healthcheck_namespace=None,
5060        healthy=None,
5061        id=None,
5062        name=None,
5063        secret_store_id=None,
5064        service_account_key=None,
5065        tags=None,
5066    ):
5067        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5068        '''
5069
5070        '''
5071        self.egress_filter = egress_filter if egress_filter is not None else ''
5072        '''
5073         A filter applied to the routing logic to pin datasource to nodes.
5074        '''
5075        self.endpoint = endpoint if endpoint is not None else ''
5076        '''
5077
5078        '''
5079        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5080        '''
5081         The path used to check the health of your connection.  Defaults to `default`.
5082        '''
5083        self.healthy = healthy if healthy is not None else False
5084        '''
5085         True if the datasource is reachable and the credentials are valid.
5086        '''
5087        self.id = id if id is not None else ''
5088        '''
5089         Unique identifier of the Resource.
5090        '''
5091        self.name = name if name is not None else ''
5092        '''
5093         Unique human-readable name of the Resource.
5094        '''
5095        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5096        '''
5097         ID of the secret store containing credentials for this resource, if any.
5098        '''
5099        self.service_account_key = service_account_key if service_account_key is not None else ''
5100        '''
5101
5102        '''
5103        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5104        '''
5105         Tags is a map of key, value pairs.
5106        '''
5107
5108    def __repr__(self):
5109        return '<sdm.GoogleGKE ' + \
5110            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5111            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5112            'endpoint: ' + repr(self.endpoint) + ' ' +\
5113            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5114            'healthy: ' + repr(self.healthy) + ' ' +\
5115            'id: ' + repr(self.id) + ' ' +\
5116            'name: ' + repr(self.name) + ' ' +\
5117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5118            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5119            'tags: ' + repr(self.tags) + ' ' +\
5120            '>'
5121
5122    def to_dict(self):
5123        return {
5124            'certificate_authority': self.certificate_authority,
5125            'egress_filter': self.egress_filter,
5126            'endpoint': self.endpoint,
5127            'healthcheck_namespace': self.healthcheck_namespace,
5128            'healthy': self.healthy,
5129            'id': self.id,
5130            'name': self.name,
5131            'secret_store_id': self.secret_store_id,
5132            'service_account_key': self.service_account_key,
5133            'tags': self.tags,
5134        }
5135
5136    @classmethod
5137    def from_dict(cls, d):
5138        return cls(
5139            certificate_authority=d.get('certificate_authority'),
5140            egress_filter=d.get('egress_filter'),
5141            endpoint=d.get('endpoint'),
5142            healthcheck_namespace=d.get('healthcheck_namespace'),
5143            healthy=d.get('healthy'),
5144            id=d.get('id'),
5145            name=d.get('name'),
5146            secret_store_id=d.get('secret_store_id'),
5147            service_account_key=d.get('service_account_key'),
5148            tags=d.get('tags'),
5149        )
#   GoogleGKE( certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None )
View Source
5054    def __init__(
5055        self,
5056        certificate_authority=None,
5057        egress_filter=None,
5058        endpoint=None,
5059        healthcheck_namespace=None,
5060        healthy=None,
5061        id=None,
5062        name=None,
5063        secret_store_id=None,
5064        service_account_key=None,
5065        tags=None,
5066    ):
5067        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5068        '''
5069
5070        '''
5071        self.egress_filter = egress_filter if egress_filter is not None else ''
5072        '''
5073         A filter applied to the routing logic to pin datasource to nodes.
5074        '''
5075        self.endpoint = endpoint if endpoint is not None else ''
5076        '''
5077
5078        '''
5079        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5080        '''
5081         The path used to check the health of your connection.  Defaults to `default`.
5082        '''
5083        self.healthy = healthy if healthy is not None else False
5084        '''
5085         True if the datasource is reachable and the credentials are valid.
5086        '''
5087        self.id = id if id is not None else ''
5088        '''
5089         Unique identifier of the Resource.
5090        '''
5091        self.name = name if name is not None else ''
5092        '''
5093         Unique human-readable name of the Resource.
5094        '''
5095        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5096        '''
5097         ID of the secret store containing credentials for this resource, if any.
5098        '''
5099        self.service_account_key = service_account_key if service_account_key is not None else ''
5100        '''
5101
5102        '''
5103        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5104        '''
5105         Tags is a map of key, value pairs.
5106        '''
#   certificate_authority
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   service_account_key
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
5122    def to_dict(self):
5123        return {
5124            'certificate_authority': self.certificate_authority,
5125            'egress_filter': self.egress_filter,
5126            'endpoint': self.endpoint,
5127            'healthcheck_namespace': self.healthcheck_namespace,
5128            'healthy': self.healthy,
5129            'id': self.id,
5130            'name': self.name,
5131            'secret_store_id': self.secret_store_id,
5132            'service_account_key': self.service_account_key,
5133            'tags': self.tags,
5134        }
#  
@classmethod
def from_dict(cls, d):
View Source
5136    @classmethod
5137    def from_dict(cls, d):
5138        return cls(
5139            certificate_authority=d.get('certificate_authority'),
5140            egress_filter=d.get('egress_filter'),
5141            endpoint=d.get('endpoint'),
5142            healthcheck_namespace=d.get('healthcheck_namespace'),
5143            healthy=d.get('healthy'),
5144            id=d.get('id'),
5145            name=d.get('name'),
5146            secret_store_id=d.get('secret_store_id'),
5147            service_account_key=d.get('service_account_key'),
5148            tags=d.get('tags'),
5149        )
#   class GoogleGKEUserImpersonation:
View Source
5152class GoogleGKEUserImpersonation:
5153    '''
5154
5155    '''
5156    __slots__ = [
5157        'certificate_authority',
5158        'egress_filter',
5159        'endpoint',
5160        'healthcheck_namespace',
5161        'healthy',
5162        'id',
5163        'name',
5164        'secret_store_id',
5165        'service_account_key',
5166        'tags',
5167    ]
5168
5169    def __init__(
5170        self,
5171        certificate_authority=None,
5172        egress_filter=None,
5173        endpoint=None,
5174        healthcheck_namespace=None,
5175        healthy=None,
5176        id=None,
5177        name=None,
5178        secret_store_id=None,
5179        service_account_key=None,
5180        tags=None,
5181    ):
5182        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5183        '''
5184
5185        '''
5186        self.egress_filter = egress_filter if egress_filter is not None else ''
5187        '''
5188         A filter applied to the routing logic to pin datasource to nodes.
5189        '''
5190        self.endpoint = endpoint if endpoint is not None else ''
5191        '''
5192
5193        '''
5194        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5195        '''
5196         The path used to check the health of your connection.  Defaults to `default`.
5197        '''
5198        self.healthy = healthy if healthy is not None else False
5199        '''
5200         True if the datasource is reachable and the credentials are valid.
5201        '''
5202        self.id = id if id is not None else ''
5203        '''
5204         Unique identifier of the Resource.
5205        '''
5206        self.name = name if name is not None else ''
5207        '''
5208         Unique human-readable name of the Resource.
5209        '''
5210        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5211        '''
5212         ID of the secret store containing credentials for this resource, if any.
5213        '''
5214        self.service_account_key = service_account_key if service_account_key is not None else ''
5215        '''
5216
5217        '''
5218        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5219        '''
5220         Tags is a map of key, value pairs.
5221        '''
5222
5223    def __repr__(self):
5224        return '<sdm.GoogleGKEUserImpersonation ' + \
5225            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5226            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5227            'endpoint: ' + repr(self.endpoint) + ' ' +\
5228            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5229            'healthy: ' + repr(self.healthy) + ' ' +\
5230            'id: ' + repr(self.id) + ' ' +\
5231            'name: ' + repr(self.name) + ' ' +\
5232            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5233            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5234            'tags: ' + repr(self.tags) + ' ' +\
5235            '>'
5236
5237    def to_dict(self):
5238        return {
5239            'certificate_authority': self.certificate_authority,
5240            'egress_filter': self.egress_filter,
5241            'endpoint': self.endpoint,
5242            'healthcheck_namespace': self.healthcheck_namespace,
5243            'healthy': self.healthy,
5244            'id': self.id,
5245            'name': self.name,
5246            'secret_store_id': self.secret_store_id,
5247            'service_account_key': self.service_account_key,
5248            'tags': self.tags,
5249        }
5250
5251    @classmethod
5252    def from_dict(cls, d):
5253        return cls(
5254            certificate_authority=d.get('certificate_authority'),
5255            egress_filter=d.get('egress_filter'),
5256            endpoint=d.get('endpoint'),
5257            healthcheck_namespace=d.get('healthcheck_namespace'),
5258            healthy=d.get('healthy'),
5259            id=d.get('id'),
5260            name=d.get('name'),
5261            secret_store_id=d.get('secret_store_id'),
5262            service_account_key=d.get('service_account_key'),
5263            tags=d.get('tags'),
5264        )
#   GoogleGKEUserImpersonation( certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None )
View Source
5169    def __init__(
5170        self,
5171        certificate_authority=None,
5172        egress_filter=None,
5173        endpoint=None,
5174        healthcheck_namespace=None,
5175        healthy=None,
5176        id=None,
5177        name=None,
5178        secret_store_id=None,
5179        service_account_key=None,
5180        tags=None,
5181    ):
5182        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5183        '''
5184
5185        '''
5186        self.egress_filter = egress_filter if egress_filter is not None else ''
5187        '''
5188         A filter applied to the routing logic to pin datasource to nodes.
5189        '''
5190        self.endpoint = endpoint if endpoint is not None else ''
5191        '''
5192
5193        '''
5194        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5195        '''
5196         The path used to check the health of your connection.  Defaults to `default`.
5197        '''
5198        self.healthy = healthy if healthy is not None else False
5199        '''
5200         True if the datasource is reachable and the credentials are valid.
5201        '''
5202        self.id = id if id is not None else ''
5203        '''
5204         Unique identifier of the Resource.
5205        '''
5206        self.name = name if name is not None else ''
5207        '''
5208         Unique human-readable name of the Resource.
5209        '''
5210        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5211        '''
5212         ID of the secret store containing credentials for this resource, if any.
5213        '''
5214        self.service_account_key = service_account_key if service_account_key is not None else ''
5215        '''
5216
5217        '''
5218        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5219        '''
5220         Tags is a map of key, value pairs.
5221        '''
#   certificate_authority
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   service_account_key
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
5237    def to_dict(self):
5238        return {
5239            'certificate_authority': self.certificate_authority,
5240            'egress_filter': self.egress_filter,
5241            'endpoint': self.endpoint,
5242            'healthcheck_namespace': self.healthcheck_namespace,
5243            'healthy': self.healthy,
5244            'id': self.id,
5245            'name': self.name,
5246            'secret_store_id': self.secret_store_id,
5247            'service_account_key': self.service_account_key,
5248            'tags': self.tags,
5249        }
#  
@classmethod
def from_dict(cls, d):
View Source
5251    @classmethod
5252    def from_dict(cls, d):
5253        return cls(
5254            certificate_authority=d.get('certificate_authority'),
5255            egress_filter=d.get('egress_filter'),
5256            endpoint=d.get('endpoint'),
5257            healthcheck_namespace=d.get('healthcheck_namespace'),
5258            healthy=d.get('healthy'),
5259            id=d.get('id'),
5260            name=d.get('name'),
5261            secret_store_id=d.get('secret_store_id'),
5262            service_account_key=d.get('service_account_key'),
5263            tags=d.get('tags'),
5264        )
#   class Greenplum:
View Source
5267class Greenplum:
5268    '''
5269
5270    '''
5271    __slots__ = [
5272        'database',
5273        'egress_filter',
5274        'healthy',
5275        'hostname',
5276        'id',
5277        'name',
5278        'override_database',
5279        'password',
5280        'port',
5281        'port_override',
5282        'secret_store_id',
5283        'tags',
5284        'username',
5285    ]
5286
5287    def __init__(
5288        self,
5289        database=None,
5290        egress_filter=None,
5291        healthy=None,
5292        hostname=None,
5293        id=None,
5294        name=None,
5295        override_database=None,
5296        password=None,
5297        port=None,
5298        port_override=None,
5299        secret_store_id=None,
5300        tags=None,
5301        username=None,
5302    ):
5303        self.database = database if database is not None else ''
5304        '''
5305
5306        '''
5307        self.egress_filter = egress_filter if egress_filter is not None else ''
5308        '''
5309         A filter applied to the routing logic to pin datasource to nodes.
5310        '''
5311        self.healthy = healthy if healthy is not None else False
5312        '''
5313         True if the datasource is reachable and the credentials are valid.
5314        '''
5315        self.hostname = hostname if hostname is not None else ''
5316        '''
5317
5318        '''
5319        self.id = id if id is not None else ''
5320        '''
5321         Unique identifier of the Resource.
5322        '''
5323        self.name = name if name is not None else ''
5324        '''
5325         Unique human-readable name of the Resource.
5326        '''
5327        self.override_database = override_database if override_database is not None else False
5328        '''
5329
5330        '''
5331        self.password = password if password is not None else ''
5332        '''
5333
5334        '''
5335        self.port = port if port is not None else 0
5336        '''
5337
5338        '''
5339        self.port_override = port_override if port_override is not None else 0
5340        '''
5341
5342        '''
5343        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5344        '''
5345         ID of the secret store containing credentials for this resource, if any.
5346        '''
5347        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5348        '''
5349         Tags is a map of key, value pairs.
5350        '''
5351        self.username = username if username is not None else ''
5352        '''
5353
5354        '''
5355
5356    def __repr__(self):
5357        return '<sdm.Greenplum ' + \
5358            'database: ' + repr(self.database) + ' ' +\
5359            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5360            'healthy: ' + repr(self.healthy) + ' ' +\
5361            'hostname: ' + repr(self.hostname) + ' ' +\
5362            'id: ' + repr(self.id) + ' ' +\
5363            'name: ' + repr(self.name) + ' ' +\
5364            'override_database: ' + repr(self.override_database) + ' ' +\
5365            'password: ' + repr(self.password) + ' ' +\
5366            'port: ' + repr(self.port) + ' ' +\
5367            'port_override: ' + repr(self.port_override) + ' ' +\
5368            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5369            'tags: ' + repr(self.tags) + ' ' +\
5370            'username: ' + repr(self.username) + ' ' +\
5371            '>'
5372
5373    def to_dict(self):
5374        return {
5375            'database': self.database,
5376            'egress_filter': self.egress_filter,
5377            'healthy': self.healthy,
5378            'hostname': self.hostname,
5379            'id': self.id,
5380            'name': self.name,
5381            'override_database': self.override_database,
5382            'password': self.password,
5383            'port': self.port,
5384            'port_override': self.port_override,
5385            'secret_store_id': self.secret_store_id,
5386            'tags': self.tags,
5387            'username': self.username,
5388        }
5389
5390    @classmethod
5391    def from_dict(cls, d):
5392        return cls(
5393            database=d.get('database'),
5394            egress_filter=d.get('egress_filter'),
5395            healthy=d.get('healthy'),
5396            hostname=d.get('hostname'),
5397            id=d.get('id'),
5398            name=d.get('name'),
5399            override_database=d.get('override_database'),
5400            password=d.get('password'),
5401            port=d.get('port'),
5402            port_override=d.get('port_override'),
5403            secret_store_id=d.get('secret_store_id'),
5404            tags=d.get('tags'),
5405            username=d.get('username'),
5406        )
#   Greenplum( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
5287    def __init__(
5288        self,
5289        database=None,
5290        egress_filter=None,
5291        healthy=None,
5292        hostname=None,
5293        id=None,
5294        name=None,
5295        override_database=None,
5296        password=None,
5297        port=None,
5298        port_override=None,
5299        secret_store_id=None,
5300        tags=None,
5301        username=None,
5302    ):
5303        self.database = database if database is not None else ''
5304        '''
5305
5306        '''
5307        self.egress_filter = egress_filter if egress_filter is not None else ''
5308        '''
5309         A filter applied to the routing logic to pin datasource to nodes.
5310        '''
5311        self.healthy = healthy if healthy is not None else False
5312        '''
5313         True if the datasource is reachable and the credentials are valid.
5314        '''
5315        self.hostname = hostname if hostname is not None else ''
5316        '''
5317
5318        '''
5319        self.id = id if id is not None else ''
5320        '''
5321         Unique identifier of the Resource.
5322        '''
5323        self.name = name if name is not None else ''
5324        '''
5325         Unique human-readable name of the Resource.
5326        '''
5327        self.override_database = override_database if override_database is not None else False
5328        '''
5329
5330        '''
5331        self.password = password if password is not None else ''
5332        '''
5333
5334        '''
5335        self.port = port if port is not None else 0
5336        '''
5337
5338        '''
5339        self.port_override = port_override if port_override is not None else 0
5340        '''
5341
5342        '''
5343        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5344        '''
5345         ID of the secret store containing credentials for this resource, if any.
5346        '''
5347        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5348        '''
5349         Tags is a map of key, value pairs.
5350        '''
5351        self.username = username if username is not None else ''
5352        '''
5353
5354        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
5373    def to_dict(self):
5374        return {
5375            'database': self.database,
5376            'egress_filter': self.egress_filter,
5377            'healthy': self.healthy,
5378            'hostname': self.hostname,
5379            'id': self.id,
5380            'name': self.name,
5381            'override_database': self.override_database,
5382            'password': self.password,
5383            'port': self.port,
5384            'port_override': self.port_override,
5385            'secret_store_id': self.secret_store_id,
5386            'tags': self.tags,
5387            'username': self.username,
5388        }
#  
@classmethod
def from_dict(cls, d):
View Source
5390    @classmethod
5391    def from_dict(cls, d):
5392        return cls(
5393            database=d.get('database'),
5394            egress_filter=d.get('egress_filter'),
5395            healthy=d.get('healthy'),
5396            hostname=d.get('hostname'),
5397            id=d.get('id'),
5398            name=d.get('name'),
5399            override_database=d.get('override_database'),
5400            password=d.get('password'),
5401            port=d.get('port'),
5402            port_override=d.get('port_override'),
5403            secret_store_id=d.get('secret_store_id'),
5404            tags=d.get('tags'),
5405            username=d.get('username'),
5406        )
#   class HTTPAuth:
View Source
5409class HTTPAuth:
5410    '''
5411
5412    '''
5413    __slots__ = [
5414        'auth_header',
5415        'default_path',
5416        'egress_filter',
5417        'headers_blacklist',
5418        'healthcheck_path',
5419        'healthy',
5420        'id',
5421        'name',
5422        'secret_store_id',
5423        'subdomain',
5424        'tags',
5425        'url',
5426    ]
5427
5428    def __init__(
5429        self,
5430        auth_header=None,
5431        default_path=None,
5432        egress_filter=None,
5433        headers_blacklist=None,
5434        healthcheck_path=None,
5435        healthy=None,
5436        id=None,
5437        name=None,
5438        secret_store_id=None,
5439        subdomain=None,
5440        tags=None,
5441        url=None,
5442    ):
5443        self.auth_header = auth_header if auth_header is not None else ''
5444        '''
5445
5446        '''
5447        self.default_path = default_path if default_path is not None else ''
5448        '''
5449
5450        '''
5451        self.egress_filter = egress_filter if egress_filter is not None else ''
5452        '''
5453         A filter applied to the routing logic to pin datasource to nodes.
5454        '''
5455        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5456        '''
5457
5458        '''
5459        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5460        '''
5461
5462        '''
5463        self.healthy = healthy if healthy is not None else False
5464        '''
5465         True if the datasource is reachable and the credentials are valid.
5466        '''
5467        self.id = id if id is not None else ''
5468        '''
5469         Unique identifier of the Resource.
5470        '''
5471        self.name = name if name is not None else ''
5472        '''
5473         Unique human-readable name of the Resource.
5474        '''
5475        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5476        '''
5477         ID of the secret store containing credentials for this resource, if any.
5478        '''
5479        self.subdomain = subdomain if subdomain is not None else ''
5480        '''
5481
5482        '''
5483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5484        '''
5485         Tags is a map of key, value pairs.
5486        '''
5487        self.url = url if url is not None else ''
5488        '''
5489
5490        '''
5491
5492    def __repr__(self):
5493        return '<sdm.HTTPAuth ' + \
5494            'auth_header: ' + repr(self.auth_header) + ' ' +\
5495            'default_path: ' + repr(self.default_path) + ' ' +\
5496            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5497            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5498            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5499            'healthy: ' + repr(self.healthy) + ' ' +\
5500            'id: ' + repr(self.id) + ' ' +\
5501            'name: ' + repr(self.name) + ' ' +\
5502            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5503            'subdomain: ' + repr(self.subdomain) + ' ' +\
5504            'tags: ' + repr(self.tags) + ' ' +\
5505            'url: ' + repr(self.url) + ' ' +\
5506            '>'
5507
5508    def to_dict(self):
5509        return {
5510            'auth_header': self.auth_header,
5511            'default_path': self.default_path,
5512            'egress_filter': self.egress_filter,
5513            'headers_blacklist': self.headers_blacklist,
5514            'healthcheck_path': self.healthcheck_path,
5515            'healthy': self.healthy,
5516            'id': self.id,
5517            'name': self.name,
5518            'secret_store_id': self.secret_store_id,
5519            'subdomain': self.subdomain,
5520            'tags': self.tags,
5521            'url': self.url,
5522        }
5523
5524    @classmethod
5525    def from_dict(cls, d):
5526        return cls(
5527            auth_header=d.get('auth_header'),
5528            default_path=d.get('default_path'),
5529            egress_filter=d.get('egress_filter'),
5530            headers_blacklist=d.get('headers_blacklist'),
5531            healthcheck_path=d.get('healthcheck_path'),
5532            healthy=d.get('healthy'),
5533            id=d.get('id'),
5534            name=d.get('name'),
5535            secret_store_id=d.get('secret_store_id'),
5536            subdomain=d.get('subdomain'),
5537            tags=d.get('tags'),
5538            url=d.get('url'),
5539        )
#   HTTPAuth( auth_header=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None )
View Source
5428    def __init__(
5429        self,
5430        auth_header=None,
5431        default_path=None,
5432        egress_filter=None,
5433        headers_blacklist=None,
5434        healthcheck_path=None,
5435        healthy=None,
5436        id=None,
5437        name=None,
5438        secret_store_id=None,
5439        subdomain=None,
5440        tags=None,
5441        url=None,
5442    ):
5443        self.auth_header = auth_header if auth_header is not None else ''
5444        '''
5445
5446        '''
5447        self.default_path = default_path if default_path is not None else ''
5448        '''
5449
5450        '''
5451        self.egress_filter = egress_filter if egress_filter is not None else ''
5452        '''
5453         A filter applied to the routing logic to pin datasource to nodes.
5454        '''
5455        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5456        '''
5457
5458        '''
5459        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5460        '''
5461
5462        '''
5463        self.healthy = healthy if healthy is not None else False
5464        '''
5465         True if the datasource is reachable and the credentials are valid.
5466        '''
5467        self.id = id if id is not None else ''
5468        '''
5469         Unique identifier of the Resource.
5470        '''
5471        self.name = name if name is not None else ''
5472        '''
5473         Unique human-readable name of the Resource.
5474        '''
5475        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5476        '''
5477         ID of the secret store containing credentials for this resource, if any.
5478        '''
5479        self.subdomain = subdomain if subdomain is not None else ''
5480        '''
5481
5482        '''
5483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5484        '''
5485         Tags is a map of key, value pairs.
5486        '''
5487        self.url = url if url is not None else ''
5488        '''
5489
5490        '''
#   auth_header
#   default_path
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   headers_blacklist
#   healthcheck_path
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   subdomain
#   tags

Tags is a map of key, value pairs.

#   url
#   def to_dict(self):
View Source
5508    def to_dict(self):
5509        return {
5510            'auth_header': self.auth_header,
5511            'default_path': self.default_path,
5512            'egress_filter': self.egress_filter,
5513            'headers_blacklist': self.headers_blacklist,
5514            'healthcheck_path': self.healthcheck_path,
5515            'healthy': self.healthy,
5516            'id': self.id,
5517            'name': self.name,
5518            'secret_store_id': self.secret_store_id,
5519            'subdomain': self.subdomain,
5520            'tags': self.tags,
5521            'url': self.url,
5522        }
#  
@classmethod
def from_dict(cls, d):
View Source
5524    @classmethod
5525    def from_dict(cls, d):
5526        return cls(
5527            auth_header=d.get('auth_header'),
5528            default_path=d.get('default_path'),
5529            egress_filter=d.get('egress_filter'),
5530            headers_blacklist=d.get('headers_blacklist'),
5531            healthcheck_path=d.get('healthcheck_path'),
5532            healthy=d.get('healthy'),
5533            id=d.get('id'),
5534            name=d.get('name'),
5535            secret_store_id=d.get('secret_store_id'),
5536            subdomain=d.get('subdomain'),
5537            tags=d.get('tags'),
5538            url=d.get('url'),
5539        )
#   class HTTPBasicAuth:
View Source
5542class HTTPBasicAuth:
5543    '''
5544
5545    '''
5546    __slots__ = [
5547        'default_path',
5548        'egress_filter',
5549        'headers_blacklist',
5550        'healthcheck_path',
5551        'healthy',
5552        'id',
5553        'name',
5554        'password',
5555        'secret_store_id',
5556        'subdomain',
5557        'tags',
5558        'url',
5559        'username',
5560    ]
5561
5562    def __init__(
5563        self,
5564        default_path=None,
5565        egress_filter=None,
5566        headers_blacklist=None,
5567        healthcheck_path=None,
5568        healthy=None,
5569        id=None,
5570        name=None,
5571        password=None,
5572        secret_store_id=None,
5573        subdomain=None,
5574        tags=None,
5575        url=None,
5576        username=None,
5577    ):
5578        self.default_path = default_path if default_path is not None else ''
5579        '''
5580
5581        '''
5582        self.egress_filter = egress_filter if egress_filter is not None else ''
5583        '''
5584         A filter applied to the routing logic to pin datasource to nodes.
5585        '''
5586        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5587        '''
5588
5589        '''
5590        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5591        '''
5592
5593        '''
5594        self.healthy = healthy if healthy is not None else False
5595        '''
5596         True if the datasource is reachable and the credentials are valid.
5597        '''
5598        self.id = id if id is not None else ''
5599        '''
5600         Unique identifier of the Resource.
5601        '''
5602        self.name = name if name is not None else ''
5603        '''
5604         Unique human-readable name of the Resource.
5605        '''
5606        self.password = password if password is not None else ''
5607        '''
5608
5609        '''
5610        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5611        '''
5612         ID of the secret store containing credentials for this resource, if any.
5613        '''
5614        self.subdomain = subdomain if subdomain is not None else ''
5615        '''
5616
5617        '''
5618        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5619        '''
5620         Tags is a map of key, value pairs.
5621        '''
5622        self.url = url if url is not None else ''
5623        '''
5624
5625        '''
5626        self.username = username if username is not None else ''
5627        '''
5628
5629        '''
5630
5631    def __repr__(self):
5632        return '<sdm.HTTPBasicAuth ' + \
5633            'default_path: ' + repr(self.default_path) + ' ' +\
5634            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5635            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5636            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5637            'healthy: ' + repr(self.healthy) + ' ' +\
5638            'id: ' + repr(self.id) + ' ' +\
5639            'name: ' + repr(self.name) + ' ' +\
5640            'password: ' + repr(self.password) + ' ' +\
5641            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5642            'subdomain: ' + repr(self.subdomain) + ' ' +\
5643            'tags: ' + repr(self.tags) + ' ' +\
5644            'url: ' + repr(self.url) + ' ' +\
5645            'username: ' + repr(self.username) + ' ' +\
5646            '>'
5647
5648    def to_dict(self):
5649        return {
5650            'default_path': self.default_path,
5651            'egress_filter': self.egress_filter,
5652            'headers_blacklist': self.headers_blacklist,
5653            'healthcheck_path': self.healthcheck_path,
5654            'healthy': self.healthy,
5655            'id': self.id,
5656            'name': self.name,
5657            'password': self.password,
5658            'secret_store_id': self.secret_store_id,
5659            'subdomain': self.subdomain,
5660            'tags': self.tags,
5661            'url': self.url,
5662            'username': self.username,
5663        }
5664
5665    @classmethod
5666    def from_dict(cls, d):
5667        return cls(
5668            default_path=d.get('default_path'),
5669            egress_filter=d.get('egress_filter'),
5670            headers_blacklist=d.get('headers_blacklist'),
5671            healthcheck_path=d.get('healthcheck_path'),
5672            healthy=d.get('healthy'),
5673            id=d.get('id'),
5674            name=d.get('name'),
5675            password=d.get('password'),
5676            secret_store_id=d.get('secret_store_id'),
5677            subdomain=d.get('subdomain'),
5678            tags=d.get('tags'),
5679            url=d.get('url'),
5680            username=d.get('username'),
5681        )
#   HTTPBasicAuth( default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None )
View Source
5562    def __init__(
5563        self,
5564        default_path=None,
5565        egress_filter=None,
5566        headers_blacklist=None,
5567        healthcheck_path=None,
5568        healthy=None,
5569        id=None,
5570        name=None,
5571        password=None,
5572        secret_store_id=None,
5573        subdomain=None,
5574        tags=None,
5575        url=None,
5576        username=None,
5577    ):
5578        self.default_path = default_path if default_path is not None else ''
5579        '''
5580
5581        '''
5582        self.egress_filter = egress_filter if egress_filter is not None else ''
5583        '''
5584         A filter applied to the routing logic to pin datasource to nodes.
5585        '''
5586        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5587        '''
5588
5589        '''
5590        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5591        '''
5592
5593        '''
5594        self.healthy = healthy if healthy is not None else False
5595        '''
5596         True if the datasource is reachable and the credentials are valid.
5597        '''
5598        self.id = id if id is not None else ''
5599        '''
5600         Unique identifier of the Resource.
5601        '''
5602        self.name = name if name is not None else ''
5603        '''
5604         Unique human-readable name of the Resource.
5605        '''
5606        self.password = password if password is not None else ''
5607        '''
5608
5609        '''
5610        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5611        '''
5612         ID of the secret store containing credentials for this resource, if any.
5613        '''
5614        self.subdomain = subdomain if subdomain is not None else ''
5615        '''
5616
5617        '''
5618        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5619        '''
5620         Tags is a map of key, value pairs.
5621        '''
5622        self.url = url if url is not None else ''
5623        '''
5624
5625        '''
5626        self.username = username if username is not None else ''
5627        '''
5628
5629        '''
#   default_path
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   headers_blacklist
#   healthcheck_path
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   subdomain
#   tags

Tags is a map of key, value pairs.

#   url
#   username
#   def to_dict(self):
View Source
5648    def to_dict(self):
5649        return {
5650            'default_path': self.default_path,
5651            'egress_filter': self.egress_filter,
5652            'headers_blacklist': self.headers_blacklist,
5653            'healthcheck_path': self.healthcheck_path,
5654            'healthy': self.healthy,
5655            'id': self.id,
5656            'name': self.name,
5657            'password': self.password,
5658            'secret_store_id': self.secret_store_id,
5659            'subdomain': self.subdomain,
5660            'tags': self.tags,
5661            'url': self.url,
5662            'username': self.username,
5663        }
#  
@classmethod
def from_dict(cls, d):
View Source
5665    @classmethod
5666    def from_dict(cls, d):
5667        return cls(
5668            default_path=d.get('default_path'),
5669            egress_filter=d.get('egress_filter'),
5670            headers_blacklist=d.get('headers_blacklist'),
5671            healthcheck_path=d.get('healthcheck_path'),
5672            healthy=d.get('healthy'),
5673            id=d.get('id'),
5674            name=d.get('name'),
5675            password=d.get('password'),
5676            secret_store_id=d.get('secret_store_id'),
5677            subdomain=d.get('subdomain'),
5678            tags=d.get('tags'),
5679            url=d.get('url'),
5680            username=d.get('username'),
5681        )
#   class HTTPNoAuth:
View Source
5684class HTTPNoAuth:
5685    '''
5686
5687    '''
5688    __slots__ = [
5689        'default_path',
5690        'egress_filter',
5691        'headers_blacklist',
5692        'healthcheck_path',
5693        'healthy',
5694        'id',
5695        'name',
5696        'secret_store_id',
5697        'subdomain',
5698        'tags',
5699        'url',
5700    ]
5701
5702    def __init__(
5703        self,
5704        default_path=None,
5705        egress_filter=None,
5706        headers_blacklist=None,
5707        healthcheck_path=None,
5708        healthy=None,
5709        id=None,
5710        name=None,
5711        secret_store_id=None,
5712        subdomain=None,
5713        tags=None,
5714        url=None,
5715    ):
5716        self.default_path = default_path if default_path is not None else ''
5717        '''
5718
5719        '''
5720        self.egress_filter = egress_filter if egress_filter is not None else ''
5721        '''
5722         A filter applied to the routing logic to pin datasource to nodes.
5723        '''
5724        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5725        '''
5726
5727        '''
5728        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5729        '''
5730
5731        '''
5732        self.healthy = healthy if healthy is not None else False
5733        '''
5734         True if the datasource is reachable and the credentials are valid.
5735        '''
5736        self.id = id if id is not None else ''
5737        '''
5738         Unique identifier of the Resource.
5739        '''
5740        self.name = name if name is not None else ''
5741        '''
5742         Unique human-readable name of the Resource.
5743        '''
5744        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5745        '''
5746         ID of the secret store containing credentials for this resource, if any.
5747        '''
5748        self.subdomain = subdomain if subdomain is not None else ''
5749        '''
5750
5751        '''
5752        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5753        '''
5754         Tags is a map of key, value pairs.
5755        '''
5756        self.url = url if url is not None else ''
5757        '''
5758
5759        '''
5760
5761    def __repr__(self):
5762        return '<sdm.HTTPNoAuth ' + \
5763            'default_path: ' + repr(self.default_path) + ' ' +\
5764            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5765            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5766            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5767            'healthy: ' + repr(self.healthy) + ' ' +\
5768            'id: ' + repr(self.id) + ' ' +\
5769            'name: ' + repr(self.name) + ' ' +\
5770            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5771            'subdomain: ' + repr(self.subdomain) + ' ' +\
5772            'tags: ' + repr(self.tags) + ' ' +\
5773            'url: ' + repr(self.url) + ' ' +\
5774            '>'
5775
5776    def to_dict(self):
5777        return {
5778            'default_path': self.default_path,
5779            'egress_filter': self.egress_filter,
5780            'headers_blacklist': self.headers_blacklist,
5781            'healthcheck_path': self.healthcheck_path,
5782            'healthy': self.healthy,
5783            'id': self.id,
5784            'name': self.name,
5785            'secret_store_id': self.secret_store_id,
5786            'subdomain': self.subdomain,
5787            'tags': self.tags,
5788            'url': self.url,
5789        }
5790
5791    @classmethod
5792    def from_dict(cls, d):
5793        return cls(
5794            default_path=d.get('default_path'),
5795            egress_filter=d.get('egress_filter'),
5796            headers_blacklist=d.get('headers_blacklist'),
5797            healthcheck_path=d.get('healthcheck_path'),
5798            healthy=d.get('healthy'),
5799            id=d.get('id'),
5800            name=d.get('name'),
5801            secret_store_id=d.get('secret_store_id'),
5802            subdomain=d.get('subdomain'),
5803            tags=d.get('tags'),
5804            url=d.get('url'),
5805        )
#   HTTPNoAuth( default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None )
View Source
5702    def __init__(
5703        self,
5704        default_path=None,
5705        egress_filter=None,
5706        headers_blacklist=None,
5707        healthcheck_path=None,
5708        healthy=None,
5709        id=None,
5710        name=None,
5711        secret_store_id=None,
5712        subdomain=None,
5713        tags=None,
5714        url=None,
5715    ):
5716        self.default_path = default_path if default_path is not None else ''
5717        '''
5718
5719        '''
5720        self.egress_filter = egress_filter if egress_filter is not None else ''
5721        '''
5722         A filter applied to the routing logic to pin datasource to nodes.
5723        '''
5724        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5725        '''
5726
5727        '''
5728        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5729        '''
5730
5731        '''
5732        self.healthy = healthy if healthy is not None else False
5733        '''
5734         True if the datasource is reachable and the credentials are valid.
5735        '''
5736        self.id = id if id is not None else ''
5737        '''
5738         Unique identifier of the Resource.
5739        '''
5740        self.name = name if name is not None else ''
5741        '''
5742         Unique human-readable name of the Resource.
5743        '''
5744        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5745        '''
5746         ID of the secret store containing credentials for this resource, if any.
5747        '''
5748        self.subdomain = subdomain if subdomain is not None else ''
5749        '''
5750
5751        '''
5752        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5753        '''
5754         Tags is a map of key, value pairs.
5755        '''
5756        self.url = url if url is not None else ''
5757        '''
5758
5759        '''
#   default_path
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   headers_blacklist
#   healthcheck_path
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   subdomain
#   tags

Tags is a map of key, value pairs.

#   url
#   def to_dict(self):
View Source
5776    def to_dict(self):
5777        return {
5778            'default_path': self.default_path,
5779            'egress_filter': self.egress_filter,
5780            'headers_blacklist': self.headers_blacklist,
5781            'healthcheck_path': self.healthcheck_path,
5782            'healthy': self.healthy,
5783            'id': self.id,
5784            'name': self.name,
5785            'secret_store_id': self.secret_store_id,
5786            'subdomain': self.subdomain,
5787            'tags': self.tags,
5788            'url': self.url,
5789        }
#  
@classmethod
def from_dict(cls, d):
View Source
5791    @classmethod
5792    def from_dict(cls, d):
5793        return cls(
5794            default_path=d.get('default_path'),
5795            egress_filter=d.get('egress_filter'),
5796            headers_blacklist=d.get('headers_blacklist'),
5797            healthcheck_path=d.get('healthcheck_path'),
5798            healthy=d.get('healthy'),
5799            id=d.get('id'),
5800            name=d.get('name'),
5801            secret_store_id=d.get('secret_store_id'),
5802            subdomain=d.get('subdomain'),
5803            tags=d.get('tags'),
5804            url=d.get('url'),
5805        )
#   class Kubernetes:
View Source
5808class Kubernetes:
5809    '''
5810
5811    '''
5812    __slots__ = [
5813        'certificate_authority',
5814        'client_certificate',
5815        'client_key',
5816        'egress_filter',
5817        'healthcheck_namespace',
5818        'healthy',
5819        'hostname',
5820        'id',
5821        'name',
5822        'port',
5823        'secret_store_id',
5824        'tags',
5825    ]
5826
5827    def __init__(
5828        self,
5829        certificate_authority=None,
5830        client_certificate=None,
5831        client_key=None,
5832        egress_filter=None,
5833        healthcheck_namespace=None,
5834        healthy=None,
5835        hostname=None,
5836        id=None,
5837        name=None,
5838        port=None,
5839        secret_store_id=None,
5840        tags=None,
5841    ):
5842        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5843        '''
5844
5845        '''
5846        self.client_certificate = client_certificate if client_certificate is not None else ''
5847        '''
5848
5849        '''
5850        self.client_key = client_key if client_key is not None else ''
5851        '''
5852
5853        '''
5854        self.egress_filter = egress_filter if egress_filter is not None else ''
5855        '''
5856         A filter applied to the routing logic to pin datasource to nodes.
5857        '''
5858        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5859        '''
5860         The path used to check the health of your connection.  Defaults to `default`.
5861        '''
5862        self.healthy = healthy if healthy is not None else False
5863        '''
5864         True if the datasource is reachable and the credentials are valid.
5865        '''
5866        self.hostname = hostname if hostname is not None else ''
5867        '''
5868
5869        '''
5870        self.id = id if id is not None else ''
5871        '''
5872         Unique identifier of the Resource.
5873        '''
5874        self.name = name if name is not None else ''
5875        '''
5876         Unique human-readable name of the Resource.
5877        '''
5878        self.port = port if port is not None else 0
5879        '''
5880
5881        '''
5882        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5883        '''
5884         ID of the secret store containing credentials for this resource, if any.
5885        '''
5886        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5887        '''
5888         Tags is a map of key, value pairs.
5889        '''
5890
5891    def __repr__(self):
5892        return '<sdm.Kubernetes ' + \
5893            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5894            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
5895            'client_key: ' + repr(self.client_key) + ' ' +\
5896            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5897            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5898            'healthy: ' + repr(self.healthy) + ' ' +\
5899            'hostname: ' + repr(self.hostname) + ' ' +\
5900            'id: ' + repr(self.id) + ' ' +\
5901            'name: ' + repr(self.name) + ' ' +\
5902            'port: ' + repr(self.port) + ' ' +\
5903            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5904            'tags: ' + repr(self.tags) + ' ' +\
5905            '>'
5906
5907    def to_dict(self):
5908        return {
5909            'certificate_authority': self.certificate_authority,
5910            'client_certificate': self.client_certificate,
5911            'client_key': self.client_key,
5912            'egress_filter': self.egress_filter,
5913            'healthcheck_namespace': self.healthcheck_namespace,
5914            'healthy': self.healthy,
5915            'hostname': self.hostname,
5916            'id': self.id,
5917            'name': self.name,
5918            'port': self.port,
5919            'secret_store_id': self.secret_store_id,
5920            'tags': self.tags,
5921        }
5922
5923    @classmethod
5924    def from_dict(cls, d):
5925        return cls(
5926            certificate_authority=d.get('certificate_authority'),
5927            client_certificate=d.get('client_certificate'),
5928            client_key=d.get('client_key'),
5929            egress_filter=d.get('egress_filter'),
5930            healthcheck_namespace=d.get('healthcheck_namespace'),
5931            healthy=d.get('healthy'),
5932            hostname=d.get('hostname'),
5933            id=d.get('id'),
5934            name=d.get('name'),
5935            port=d.get('port'),
5936            secret_store_id=d.get('secret_store_id'),
5937            tags=d.get('tags'),
5938        )
#   Kubernetes( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
5827    def __init__(
5828        self,
5829        certificate_authority=None,
5830        client_certificate=None,
5831        client_key=None,
5832        egress_filter=None,
5833        healthcheck_namespace=None,
5834        healthy=None,
5835        hostname=None,
5836        id=None,
5837        name=None,
5838        port=None,
5839        secret_store_id=None,
5840        tags=None,
5841    ):
5842        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5843        '''
5844
5845        '''
5846        self.client_certificate = client_certificate if client_certificate is not None else ''
5847        '''
5848
5849        '''
5850        self.client_key = client_key if client_key is not None else ''
5851        '''
5852
5853        '''
5854        self.egress_filter = egress_filter if egress_filter is not None else ''
5855        '''
5856         A filter applied to the routing logic to pin datasource to nodes.
5857        '''
5858        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5859        '''
5860         The path used to check the health of your connection.  Defaults to `default`.
5861        '''
5862        self.healthy = healthy if healthy is not None else False
5863        '''
5864         True if the datasource is reachable and the credentials are valid.
5865        '''
5866        self.hostname = hostname if hostname is not None else ''
5867        '''
5868
5869        '''
5870        self.id = id if id is not None else ''
5871        '''
5872         Unique identifier of the Resource.
5873        '''
5874        self.name = name if name is not None else ''
5875        '''
5876         Unique human-readable name of the Resource.
5877        '''
5878        self.port = port if port is not None else 0
5879        '''
5880
5881        '''
5882        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5883        '''
5884         ID of the secret store containing credentials for this resource, if any.
5885        '''
5886        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5887        '''
5888         Tags is a map of key, value pairs.
5889        '''
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
5907    def to_dict(self):
5908        return {
5909            'certificate_authority': self.certificate_authority,
5910            'client_certificate': self.client_certificate,
5911            'client_key': self.client_key,
5912            'egress_filter': self.egress_filter,
5913            'healthcheck_namespace': self.healthcheck_namespace,
5914            'healthy': self.healthy,
5915            'hostname': self.hostname,
5916            'id': self.id,
5917            'name': self.name,
5918            'port': self.port,
5919            'secret_store_id': self.secret_store_id,
5920            'tags': self.tags,
5921        }
#  
@classmethod
def from_dict(cls, d):
View Source
5923    @classmethod
5924    def from_dict(cls, d):
5925        return cls(
5926            certificate_authority=d.get('certificate_authority'),
5927            client_certificate=d.get('client_certificate'),
5928            client_key=d.get('client_key'),
5929            egress_filter=d.get('egress_filter'),
5930            healthcheck_namespace=d.get('healthcheck_namespace'),
5931            healthy=d.get('healthy'),
5932            hostname=d.get('hostname'),
5933            id=d.get('id'),
5934            name=d.get('name'),
5935            port=d.get('port'),
5936            secret_store_id=d.get('secret_store_id'),
5937            tags=d.get('tags'),
5938        )
#   class KubernetesBasicAuth:
View Source
5941class KubernetesBasicAuth:
5942    '''
5943
5944    '''
5945    __slots__ = [
5946        'egress_filter',
5947        'healthcheck_namespace',
5948        'healthy',
5949        'hostname',
5950        'id',
5951        'name',
5952        'password',
5953        'port',
5954        'secret_store_id',
5955        'tags',
5956        'username',
5957    ]
5958
5959    def __init__(
5960        self,
5961        egress_filter=None,
5962        healthcheck_namespace=None,
5963        healthy=None,
5964        hostname=None,
5965        id=None,
5966        name=None,
5967        password=None,
5968        port=None,
5969        secret_store_id=None,
5970        tags=None,
5971        username=None,
5972    ):
5973        self.egress_filter = egress_filter if egress_filter is not None else ''
5974        '''
5975         A filter applied to the routing logic to pin datasource to nodes.
5976        '''
5977        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5978        '''
5979         The path used to check the health of your connection.  Defaults to `default`.
5980        '''
5981        self.healthy = healthy if healthy is not None else False
5982        '''
5983         True if the datasource is reachable and the credentials are valid.
5984        '''
5985        self.hostname = hostname if hostname is not None else ''
5986        '''
5987
5988        '''
5989        self.id = id if id is not None else ''
5990        '''
5991         Unique identifier of the Resource.
5992        '''
5993        self.name = name if name is not None else ''
5994        '''
5995         Unique human-readable name of the Resource.
5996        '''
5997        self.password = password if password is not None else ''
5998        '''
5999
6000        '''
6001        self.port = port if port is not None else 0
6002        '''
6003
6004        '''
6005        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6006        '''
6007         ID of the secret store containing credentials for this resource, if any.
6008        '''
6009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6010        '''
6011         Tags is a map of key, value pairs.
6012        '''
6013        self.username = username if username is not None else ''
6014        '''
6015
6016        '''
6017
6018    def __repr__(self):
6019        return '<sdm.KubernetesBasicAuth ' + \
6020            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6021            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6022            'healthy: ' + repr(self.healthy) + ' ' +\
6023            'hostname: ' + repr(self.hostname) + ' ' +\
6024            'id: ' + repr(self.id) + ' ' +\
6025            'name: ' + repr(self.name) + ' ' +\
6026            'password: ' + repr(self.password) + ' ' +\
6027            'port: ' + repr(self.port) + ' ' +\
6028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6029            'tags: ' + repr(self.tags) + ' ' +\
6030            'username: ' + repr(self.username) + ' ' +\
6031            '>'
6032
6033    def to_dict(self):
6034        return {
6035            'egress_filter': self.egress_filter,
6036            'healthcheck_namespace': self.healthcheck_namespace,
6037            'healthy': self.healthy,
6038            'hostname': self.hostname,
6039            'id': self.id,
6040            'name': self.name,
6041            'password': self.password,
6042            'port': self.port,
6043            'secret_store_id': self.secret_store_id,
6044            'tags': self.tags,
6045            'username': self.username,
6046        }
6047
6048    @classmethod
6049    def from_dict(cls, d):
6050        return cls(
6051            egress_filter=d.get('egress_filter'),
6052            healthcheck_namespace=d.get('healthcheck_namespace'),
6053            healthy=d.get('healthy'),
6054            hostname=d.get('hostname'),
6055            id=d.get('id'),
6056            name=d.get('name'),
6057            password=d.get('password'),
6058            port=d.get('port'),
6059            secret_store_id=d.get('secret_store_id'),
6060            tags=d.get('tags'),
6061            username=d.get('username'),
6062        )
#   KubernetesBasicAuth( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, secret_store_id=None, tags=None, username=None )
View Source
5959    def __init__(
5960        self,
5961        egress_filter=None,
5962        healthcheck_namespace=None,
5963        healthy=None,
5964        hostname=None,
5965        id=None,
5966        name=None,
5967        password=None,
5968        port=None,
5969        secret_store_id=None,
5970        tags=None,
5971        username=None,
5972    ):
5973        self.egress_filter = egress_filter if egress_filter is not None else ''
5974        '''
5975         A filter applied to the routing logic to pin datasource to nodes.
5976        '''
5977        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5978        '''
5979         The path used to check the health of your connection.  Defaults to `default`.
5980        '''
5981        self.healthy = healthy if healthy is not None else False
5982        '''
5983         True if the datasource is reachable and the credentials are valid.
5984        '''
5985        self.hostname = hostname if hostname is not None else ''
5986        '''
5987
5988        '''
5989        self.id = id if id is not None else ''
5990        '''
5991         Unique identifier of the Resource.
5992        '''
5993        self.name = name if name is not None else ''
5994        '''
5995         Unique human-readable name of the Resource.
5996        '''
5997        self.password = password if password is not None else ''
5998        '''
5999
6000        '''
6001        self.port = port if port is not None else 0
6002        '''
6003
6004        '''
6005        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6006        '''
6007         ID of the secret store containing credentials for this resource, if any.
6008        '''
6009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6010        '''
6011         Tags is a map of key, value pairs.
6012        '''
6013        self.username = username if username is not None else ''
6014        '''
6015
6016        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
6033    def to_dict(self):
6034        return {
6035            'egress_filter': self.egress_filter,
6036            'healthcheck_namespace': self.healthcheck_namespace,
6037            'healthy': self.healthy,
6038            'hostname': self.hostname,
6039            'id': self.id,
6040            'name': self.name,
6041            'password': self.password,
6042            'port': self.port,
6043            'secret_store_id': self.secret_store_id,
6044            'tags': self.tags,
6045            'username': self.username,
6046        }
#  
@classmethod
def from_dict(cls, d):
View Source
6048    @classmethod
6049    def from_dict(cls, d):
6050        return cls(
6051            egress_filter=d.get('egress_filter'),
6052            healthcheck_namespace=d.get('healthcheck_namespace'),
6053            healthy=d.get('healthy'),
6054            hostname=d.get('hostname'),
6055            id=d.get('id'),
6056            name=d.get('name'),
6057            password=d.get('password'),
6058            port=d.get('port'),
6059            secret_store_id=d.get('secret_store_id'),
6060            tags=d.get('tags'),
6061            username=d.get('username'),
6062        )
#   class KubernetesServiceAccount:
View Source
6065class KubernetesServiceAccount:
6066    '''
6067
6068    '''
6069    __slots__ = [
6070        'egress_filter',
6071        'healthcheck_namespace',
6072        'healthy',
6073        'hostname',
6074        'id',
6075        'name',
6076        'port',
6077        'secret_store_id',
6078        'tags',
6079        'token',
6080    ]
6081
6082    def __init__(
6083        self,
6084        egress_filter=None,
6085        healthcheck_namespace=None,
6086        healthy=None,
6087        hostname=None,
6088        id=None,
6089        name=None,
6090        port=None,
6091        secret_store_id=None,
6092        tags=None,
6093        token=None,
6094    ):
6095        self.egress_filter = egress_filter if egress_filter is not None else ''
6096        '''
6097         A filter applied to the routing logic to pin datasource to nodes.
6098        '''
6099        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6100        '''
6101         The path used to check the health of your connection.  Defaults to `default`.
6102        '''
6103        self.healthy = healthy if healthy is not None else False
6104        '''
6105         True if the datasource is reachable and the credentials are valid.
6106        '''
6107        self.hostname = hostname if hostname is not None else ''
6108        '''
6109
6110        '''
6111        self.id = id if id is not None else ''
6112        '''
6113         Unique identifier of the Resource.
6114        '''
6115        self.name = name if name is not None else ''
6116        '''
6117         Unique human-readable name of the Resource.
6118        '''
6119        self.port = port if port is not None else 0
6120        '''
6121
6122        '''
6123        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6124        '''
6125         ID of the secret store containing credentials for this resource, if any.
6126        '''
6127        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6128        '''
6129         Tags is a map of key, value pairs.
6130        '''
6131        self.token = token if token is not None else ''
6132        '''
6133
6134        '''
6135
6136    def __repr__(self):
6137        return '<sdm.KubernetesServiceAccount ' + \
6138            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6139            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6140            'healthy: ' + repr(self.healthy) + ' ' +\
6141            'hostname: ' + repr(self.hostname) + ' ' +\
6142            'id: ' + repr(self.id) + ' ' +\
6143            'name: ' + repr(self.name) + ' ' +\
6144            'port: ' + repr(self.port) + ' ' +\
6145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6146            'tags: ' + repr(self.tags) + ' ' +\
6147            'token: ' + repr(self.token) + ' ' +\
6148            '>'
6149
6150    def to_dict(self):
6151        return {
6152            'egress_filter': self.egress_filter,
6153            'healthcheck_namespace': self.healthcheck_namespace,
6154            'healthy': self.healthy,
6155            'hostname': self.hostname,
6156            'id': self.id,
6157            'name': self.name,
6158            'port': self.port,
6159            'secret_store_id': self.secret_store_id,
6160            'tags': self.tags,
6161            'token': self.token,
6162        }
6163
6164    @classmethod
6165    def from_dict(cls, d):
6166        return cls(
6167            egress_filter=d.get('egress_filter'),
6168            healthcheck_namespace=d.get('healthcheck_namespace'),
6169            healthy=d.get('healthy'),
6170            hostname=d.get('hostname'),
6171            id=d.get('id'),
6172            name=d.get('name'),
6173            port=d.get('port'),
6174            secret_store_id=d.get('secret_store_id'),
6175            tags=d.get('tags'),
6176            token=d.get('token'),
6177        )
#   KubernetesServiceAccount( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
6082    def __init__(
6083        self,
6084        egress_filter=None,
6085        healthcheck_namespace=None,
6086        healthy=None,
6087        hostname=None,
6088        id=None,
6089        name=None,
6090        port=None,
6091        secret_store_id=None,
6092        tags=None,
6093        token=None,
6094    ):
6095        self.egress_filter = egress_filter if egress_filter is not None else ''
6096        '''
6097         A filter applied to the routing logic to pin datasource to nodes.
6098        '''
6099        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6100        '''
6101         The path used to check the health of your connection.  Defaults to `default`.
6102        '''
6103        self.healthy = healthy if healthy is not None else False
6104        '''
6105         True if the datasource is reachable and the credentials are valid.
6106        '''
6107        self.hostname = hostname if hostname is not None else ''
6108        '''
6109
6110        '''
6111        self.id = id if id is not None else ''
6112        '''
6113         Unique identifier of the Resource.
6114        '''
6115        self.name = name if name is not None else ''
6116        '''
6117         Unique human-readable name of the Resource.
6118        '''
6119        self.port = port if port is not None else 0
6120        '''
6121
6122        '''
6123        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6124        '''
6125         ID of the secret store containing credentials for this resource, if any.
6126        '''
6127        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6128        '''
6129         Tags is a map of key, value pairs.
6130        '''
6131        self.token = token if token is not None else ''
6132        '''
6133
6134        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   token
#   def to_dict(self):
View Source
6150    def to_dict(self):
6151        return {
6152            'egress_filter': self.egress_filter,
6153            'healthcheck_namespace': self.healthcheck_namespace,
6154            'healthy': self.healthy,
6155            'hostname': self.hostname,
6156            'id': self.id,
6157            'name': self.name,
6158            'port': self.port,
6159            'secret_store_id': self.secret_store_id,
6160            'tags': self.tags,
6161            'token': self.token,
6162        }
#  
@classmethod
def from_dict(cls, d):
View Source
6164    @classmethod
6165    def from_dict(cls, d):
6166        return cls(
6167            egress_filter=d.get('egress_filter'),
6168            healthcheck_namespace=d.get('healthcheck_namespace'),
6169            healthy=d.get('healthy'),
6170            hostname=d.get('hostname'),
6171            id=d.get('id'),
6172            name=d.get('name'),
6173            port=d.get('port'),
6174            secret_store_id=d.get('secret_store_id'),
6175            tags=d.get('tags'),
6176            token=d.get('token'),
6177        )
#   class KubernetesServiceAccountUserImpersonation:
View Source
6180class KubernetesServiceAccountUserImpersonation:
6181    '''
6182
6183    '''
6184    __slots__ = [
6185        'egress_filter',
6186        'healthcheck_namespace',
6187        'healthy',
6188        'hostname',
6189        'id',
6190        'name',
6191        'port',
6192        'secret_store_id',
6193        'tags',
6194        'token',
6195    ]
6196
6197    def __init__(
6198        self,
6199        egress_filter=None,
6200        healthcheck_namespace=None,
6201        healthy=None,
6202        hostname=None,
6203        id=None,
6204        name=None,
6205        port=None,
6206        secret_store_id=None,
6207        tags=None,
6208        token=None,
6209    ):
6210        self.egress_filter = egress_filter if egress_filter is not None else ''
6211        '''
6212         A filter applied to the routing logic to pin datasource to nodes.
6213        '''
6214        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6215        '''
6216         The path used to check the health of your connection.  Defaults to `default`.
6217        '''
6218        self.healthy = healthy if healthy is not None else False
6219        '''
6220         True if the datasource is reachable and the credentials are valid.
6221        '''
6222        self.hostname = hostname if hostname is not None else ''
6223        '''
6224
6225        '''
6226        self.id = id if id is not None else ''
6227        '''
6228         Unique identifier of the Resource.
6229        '''
6230        self.name = name if name is not None else ''
6231        '''
6232         Unique human-readable name of the Resource.
6233        '''
6234        self.port = port if port is not None else 0
6235        '''
6236
6237        '''
6238        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6239        '''
6240         ID of the secret store containing credentials for this resource, if any.
6241        '''
6242        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6243        '''
6244         Tags is a map of key, value pairs.
6245        '''
6246        self.token = token if token is not None else ''
6247        '''
6248
6249        '''
6250
6251    def __repr__(self):
6252        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6253            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6254            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6255            'healthy: ' + repr(self.healthy) + ' ' +\
6256            'hostname: ' + repr(self.hostname) + ' ' +\
6257            'id: ' + repr(self.id) + ' ' +\
6258            'name: ' + repr(self.name) + ' ' +\
6259            'port: ' + repr(self.port) + ' ' +\
6260            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6261            'tags: ' + repr(self.tags) + ' ' +\
6262            'token: ' + repr(self.token) + ' ' +\
6263            '>'
6264
6265    def to_dict(self):
6266        return {
6267            'egress_filter': self.egress_filter,
6268            'healthcheck_namespace': self.healthcheck_namespace,
6269            'healthy': self.healthy,
6270            'hostname': self.hostname,
6271            'id': self.id,
6272            'name': self.name,
6273            'port': self.port,
6274            'secret_store_id': self.secret_store_id,
6275            'tags': self.tags,
6276            'token': self.token,
6277        }
6278
6279    @classmethod
6280    def from_dict(cls, d):
6281        return cls(
6282            egress_filter=d.get('egress_filter'),
6283            healthcheck_namespace=d.get('healthcheck_namespace'),
6284            healthy=d.get('healthy'),
6285            hostname=d.get('hostname'),
6286            id=d.get('id'),
6287            name=d.get('name'),
6288            port=d.get('port'),
6289            secret_store_id=d.get('secret_store_id'),
6290            tags=d.get('tags'),
6291            token=d.get('token'),
6292        )
#   KubernetesServiceAccountUserImpersonation( egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None )
View Source
6197    def __init__(
6198        self,
6199        egress_filter=None,
6200        healthcheck_namespace=None,
6201        healthy=None,
6202        hostname=None,
6203        id=None,
6204        name=None,
6205        port=None,
6206        secret_store_id=None,
6207        tags=None,
6208        token=None,
6209    ):
6210        self.egress_filter = egress_filter if egress_filter is not None else ''
6211        '''
6212         A filter applied to the routing logic to pin datasource to nodes.
6213        '''
6214        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6215        '''
6216         The path used to check the health of your connection.  Defaults to `default`.
6217        '''
6218        self.healthy = healthy if healthy is not None else False
6219        '''
6220         True if the datasource is reachable and the credentials are valid.
6221        '''
6222        self.hostname = hostname if hostname is not None else ''
6223        '''
6224
6225        '''
6226        self.id = id if id is not None else ''
6227        '''
6228         Unique identifier of the Resource.
6229        '''
6230        self.name = name if name is not None else ''
6231        '''
6232         Unique human-readable name of the Resource.
6233        '''
6234        self.port = port if port is not None else 0
6235        '''
6236
6237        '''
6238        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6239        '''
6240         ID of the secret store containing credentials for this resource, if any.
6241        '''
6242        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6243        '''
6244         Tags is a map of key, value pairs.
6245        '''
6246        self.token = token if token is not None else ''
6247        '''
6248
6249        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   token
#   def to_dict(self):
View Source
6265    def to_dict(self):
6266        return {
6267            'egress_filter': self.egress_filter,
6268            'healthcheck_namespace': self.healthcheck_namespace,
6269            'healthy': self.healthy,
6270            'hostname': self.hostname,
6271            'id': self.id,
6272            'name': self.name,
6273            'port': self.port,
6274            'secret_store_id': self.secret_store_id,
6275            'tags': self.tags,
6276            'token': self.token,
6277        }
#  
@classmethod
def from_dict(cls, d):
View Source
6279    @classmethod
6280    def from_dict(cls, d):
6281        return cls(
6282            egress_filter=d.get('egress_filter'),
6283            healthcheck_namespace=d.get('healthcheck_namespace'),
6284            healthy=d.get('healthy'),
6285            hostname=d.get('hostname'),
6286            id=d.get('id'),
6287            name=d.get('name'),
6288            port=d.get('port'),
6289            secret_store_id=d.get('secret_store_id'),
6290            tags=d.get('tags'),
6291            token=d.get('token'),
6292        )
#   class KubernetesUserImpersonation:
View Source
6295class KubernetesUserImpersonation:
6296    '''
6297
6298    '''
6299    __slots__ = [
6300        'certificate_authority',
6301        'client_certificate',
6302        'client_key',
6303        'egress_filter',
6304        'healthcheck_namespace',
6305        'healthy',
6306        'hostname',
6307        'id',
6308        'name',
6309        'port',
6310        'secret_store_id',
6311        'tags',
6312    ]
6313
6314    def __init__(
6315        self,
6316        certificate_authority=None,
6317        client_certificate=None,
6318        client_key=None,
6319        egress_filter=None,
6320        healthcheck_namespace=None,
6321        healthy=None,
6322        hostname=None,
6323        id=None,
6324        name=None,
6325        port=None,
6326        secret_store_id=None,
6327        tags=None,
6328    ):
6329        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6330        '''
6331
6332        '''
6333        self.client_certificate = client_certificate if client_certificate is not None else ''
6334        '''
6335
6336        '''
6337        self.client_key = client_key if client_key is not None else ''
6338        '''
6339
6340        '''
6341        self.egress_filter = egress_filter if egress_filter is not None else ''
6342        '''
6343         A filter applied to the routing logic to pin datasource to nodes.
6344        '''
6345        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6346        '''
6347         The path used to check the health of your connection.  Defaults to `default`.
6348        '''
6349        self.healthy = healthy if healthy is not None else False
6350        '''
6351         True if the datasource is reachable and the credentials are valid.
6352        '''
6353        self.hostname = hostname if hostname is not None else ''
6354        '''
6355
6356        '''
6357        self.id = id if id is not None else ''
6358        '''
6359         Unique identifier of the Resource.
6360        '''
6361        self.name = name if name is not None else ''
6362        '''
6363         Unique human-readable name of the Resource.
6364        '''
6365        self.port = port if port is not None else 0
6366        '''
6367
6368        '''
6369        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6370        '''
6371         ID of the secret store containing credentials for this resource, if any.
6372        '''
6373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6374        '''
6375         Tags is a map of key, value pairs.
6376        '''
6377
6378    def __repr__(self):
6379        return '<sdm.KubernetesUserImpersonation ' + \
6380            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6381            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6382            'client_key: ' + repr(self.client_key) + ' ' +\
6383            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6384            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6385            'healthy: ' + repr(self.healthy) + ' ' +\
6386            'hostname: ' + repr(self.hostname) + ' ' +\
6387            'id: ' + repr(self.id) + ' ' +\
6388            'name: ' + repr(self.name) + ' ' +\
6389            'port: ' + repr(self.port) + ' ' +\
6390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6391            'tags: ' + repr(self.tags) + ' ' +\
6392            '>'
6393
6394    def to_dict(self):
6395        return {
6396            'certificate_authority': self.certificate_authority,
6397            'client_certificate': self.client_certificate,
6398            'client_key': self.client_key,
6399            'egress_filter': self.egress_filter,
6400            'healthcheck_namespace': self.healthcheck_namespace,
6401            'healthy': self.healthy,
6402            'hostname': self.hostname,
6403            'id': self.id,
6404            'name': self.name,
6405            'port': self.port,
6406            'secret_store_id': self.secret_store_id,
6407            'tags': self.tags,
6408        }
6409
6410    @classmethod
6411    def from_dict(cls, d):
6412        return cls(
6413            certificate_authority=d.get('certificate_authority'),
6414            client_certificate=d.get('client_certificate'),
6415            client_key=d.get('client_key'),
6416            egress_filter=d.get('egress_filter'),
6417            healthcheck_namespace=d.get('healthcheck_namespace'),
6418            healthy=d.get('healthy'),
6419            hostname=d.get('hostname'),
6420            id=d.get('id'),
6421            name=d.get('name'),
6422            port=d.get('port'),
6423            secret_store_id=d.get('secret_store_id'),
6424            tags=d.get('tags'),
6425        )
#   KubernetesUserImpersonation( certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None )
View Source
6314    def __init__(
6315        self,
6316        certificate_authority=None,
6317        client_certificate=None,
6318        client_key=None,
6319        egress_filter=None,
6320        healthcheck_namespace=None,
6321        healthy=None,
6322        hostname=None,
6323        id=None,
6324        name=None,
6325        port=None,
6326        secret_store_id=None,
6327        tags=None,
6328    ):
6329        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6330        '''
6331
6332        '''
6333        self.client_certificate = client_certificate if client_certificate is not None else ''
6334        '''
6335
6336        '''
6337        self.client_key = client_key if client_key is not None else ''
6338        '''
6339
6340        '''
6341        self.egress_filter = egress_filter if egress_filter is not None else ''
6342        '''
6343         A filter applied to the routing logic to pin datasource to nodes.
6344        '''
6345        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6346        '''
6347         The path used to check the health of your connection.  Defaults to `default`.
6348        '''
6349        self.healthy = healthy if healthy is not None else False
6350        '''
6351         True if the datasource is reachable and the credentials are valid.
6352        '''
6353        self.hostname = hostname if hostname is not None else ''
6354        '''
6355
6356        '''
6357        self.id = id if id is not None else ''
6358        '''
6359         Unique identifier of the Resource.
6360        '''
6361        self.name = name if name is not None else ''
6362        '''
6363         Unique human-readable name of the Resource.
6364        '''
6365        self.port = port if port is not None else 0
6366        '''
6367
6368        '''
6369        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6370        '''
6371         ID of the secret store containing credentials for this resource, if any.
6372        '''
6373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6374        '''
6375         Tags is a map of key, value pairs.
6376        '''
#   certificate_authority
#   client_certificate
#   client_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
6394    def to_dict(self):
6395        return {
6396            'certificate_authority': self.certificate_authority,
6397            'client_certificate': self.client_certificate,
6398            'client_key': self.client_key,
6399            'egress_filter': self.egress_filter,
6400            'healthcheck_namespace': self.healthcheck_namespace,
6401            'healthy': self.healthy,
6402            'hostname': self.hostname,
6403            'id': self.id,
6404            'name': self.name,
6405            'port': self.port,
6406            'secret_store_id': self.secret_store_id,
6407            'tags': self.tags,
6408        }
#  
@classmethod
def from_dict(cls, d):
View Source
6410    @classmethod
6411    def from_dict(cls, d):
6412        return cls(
6413            certificate_authority=d.get('certificate_authority'),
6414            client_certificate=d.get('client_certificate'),
6415            client_key=d.get('client_key'),
6416            egress_filter=d.get('egress_filter'),
6417            healthcheck_namespace=d.get('healthcheck_namespace'),
6418            healthy=d.get('healthy'),
6419            hostname=d.get('hostname'),
6420            id=d.get('id'),
6421            name=d.get('name'),
6422            port=d.get('port'),
6423            secret_store_id=d.get('secret_store_id'),
6424            tags=d.get('tags'),
6425        )
#   class MTLSMysql:
View Source
6428class MTLSMysql:
6429    '''
6430
6431    '''
6432    __slots__ = [
6433        'certificate_authority',
6434        'client_certificate',
6435        'client_key',
6436        'database',
6437        'egress_filter',
6438        'healthy',
6439        'hostname',
6440        'id',
6441        'name',
6442        'password',
6443        'port',
6444        'port_override',
6445        'secret_store_id',
6446        'server_name',
6447        'tags',
6448        'username',
6449    ]
6450
6451    def __init__(
6452        self,
6453        certificate_authority=None,
6454        client_certificate=None,
6455        client_key=None,
6456        database=None,
6457        egress_filter=None,
6458        healthy=None,
6459        hostname=None,
6460        id=None,
6461        name=None,
6462        password=None,
6463        port=None,
6464        port_override=None,
6465        secret_store_id=None,
6466        server_name=None,
6467        tags=None,
6468        username=None,
6469    ):
6470        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6471        '''
6472
6473        '''
6474        self.client_certificate = client_certificate if client_certificate is not None else ''
6475        '''
6476
6477        '''
6478        self.client_key = client_key if client_key is not None else ''
6479        '''
6480
6481        '''
6482        self.database = database if database is not None else ''
6483        '''
6484
6485        '''
6486        self.egress_filter = egress_filter if egress_filter is not None else ''
6487        '''
6488         A filter applied to the routing logic to pin datasource to nodes.
6489        '''
6490        self.healthy = healthy if healthy is not None else False
6491        '''
6492         True if the datasource is reachable and the credentials are valid.
6493        '''
6494        self.hostname = hostname if hostname is not None else ''
6495        '''
6496
6497        '''
6498        self.id = id if id is not None else ''
6499        '''
6500         Unique identifier of the Resource.
6501        '''
6502        self.name = name if name is not None else ''
6503        '''
6504         Unique human-readable name of the Resource.
6505        '''
6506        self.password = password if password is not None else ''
6507        '''
6508
6509        '''
6510        self.port = port if port is not None else 0
6511        '''
6512
6513        '''
6514        self.port_override = port_override if port_override is not None else 0
6515        '''
6516
6517        '''
6518        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6519        '''
6520         ID of the secret store containing credentials for this resource, if any.
6521        '''
6522        self.server_name = server_name if server_name is not None else ''
6523        '''
6524
6525        '''
6526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6527        '''
6528         Tags is a map of key, value pairs.
6529        '''
6530        self.username = username if username is not None else ''
6531        '''
6532
6533        '''
6534
6535    def __repr__(self):
6536        return '<sdm.MTLSMysql ' + \
6537            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6538            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6539            'client_key: ' + repr(self.client_key) + ' ' +\
6540            'database: ' + repr(self.database) + ' ' +\
6541            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6542            'healthy: ' + repr(self.healthy) + ' ' +\
6543            'hostname: ' + repr(self.hostname) + ' ' +\
6544            'id: ' + repr(self.id) + ' ' +\
6545            'name: ' + repr(self.name) + ' ' +\
6546            'password: ' + repr(self.password) + ' ' +\
6547            'port: ' + repr(self.port) + ' ' +\
6548            'port_override: ' + repr(self.port_override) + ' ' +\
6549            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6550            'server_name: ' + repr(self.server_name) + ' ' +\
6551            'tags: ' + repr(self.tags) + ' ' +\
6552            'username: ' + repr(self.username) + ' ' +\
6553            '>'
6554
6555    def to_dict(self):
6556        return {
6557            'certificate_authority': self.certificate_authority,
6558            'client_certificate': self.client_certificate,
6559            'client_key': self.client_key,
6560            'database': self.database,
6561            'egress_filter': self.egress_filter,
6562            'healthy': self.healthy,
6563            'hostname': self.hostname,
6564            'id': self.id,
6565            'name': self.name,
6566            'password': self.password,
6567            'port': self.port,
6568            'port_override': self.port_override,
6569            'secret_store_id': self.secret_store_id,
6570            'server_name': self.server_name,
6571            'tags': self.tags,
6572            'username': self.username,
6573        }
6574
6575    @classmethod
6576    def from_dict(cls, d):
6577        return cls(
6578            certificate_authority=d.get('certificate_authority'),
6579            client_certificate=d.get('client_certificate'),
6580            client_key=d.get('client_key'),
6581            database=d.get('database'),
6582            egress_filter=d.get('egress_filter'),
6583            healthy=d.get('healthy'),
6584            hostname=d.get('hostname'),
6585            id=d.get('id'),
6586            name=d.get('name'),
6587            password=d.get('password'),
6588            port=d.get('port'),
6589            port_override=d.get('port_override'),
6590            secret_store_id=d.get('secret_store_id'),
6591            server_name=d.get('server_name'),
6592            tags=d.get('tags'),
6593            username=d.get('username'),
6594        )
#   MTLSMysql( certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None )
View Source
6451    def __init__(
6452        self,
6453        certificate_authority=None,
6454        client_certificate=None,
6455        client_key=None,
6456        database=None,
6457        egress_filter=None,
6458        healthy=None,
6459        hostname=None,
6460        id=None,
6461        name=None,
6462        password=None,
6463        port=None,
6464        port_override=None,
6465        secret_store_id=None,
6466        server_name=None,
6467        tags=None,
6468        username=None,
6469    ):
6470        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6471        '''
6472
6473        '''
6474        self.client_certificate = client_certificate if client_certificate is not None else ''
6475        '''
6476
6477        '''
6478        self.client_key = client_key if client_key is not None else ''
6479        '''
6480
6481        '''
6482        self.database = database if database is not None else ''
6483        '''
6484
6485        '''
6486        self.egress_filter = egress_filter if egress_filter is not None else ''
6487        '''
6488         A filter applied to the routing logic to pin datasource to nodes.
6489        '''
6490        self.healthy = healthy if healthy is not None else False
6491        '''
6492         True if the datasource is reachable and the credentials are valid.
6493        '''
6494        self.hostname = hostname if hostname is not None else ''
6495        '''
6496
6497        '''
6498        self.id = id if id is not None else ''
6499        '''
6500         Unique identifier of the Resource.
6501        '''
6502        self.name = name if name is not None else ''
6503        '''
6504         Unique human-readable name of the Resource.
6505        '''
6506        self.password = password if password is not None else ''
6507        '''
6508
6509        '''
6510        self.port = port if port is not None else 0
6511        '''
6512
6513        '''
6514        self.port_override = port_override if port_override is not None else 0
6515        '''
6516
6517        '''
6518        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6519        '''
6520         ID of the secret store containing credentials for this resource, if any.
6521        '''
6522        self.server_name = server_name if server_name is not None else ''
6523        '''
6524
6525        '''
6526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6527        '''
6528         Tags is a map of key, value pairs.
6529        '''
6530        self.username = username if username is not None else ''
6531        '''
6532
6533        '''
#   certificate_authority
#   client_certificate
#   client_key
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   server_name
#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
6555    def to_dict(self):
6556        return {
6557            'certificate_authority': self.certificate_authority,
6558            'client_certificate': self.client_certificate,
6559            'client_key': self.client_key,
6560            'database': self.database,
6561            'egress_filter': self.egress_filter,
6562            'healthy': self.healthy,
6563            'hostname': self.hostname,
6564            'id': self.id,
6565            'name': self.name,
6566            'password': self.password,
6567            'port': self.port,
6568            'port_override': self.port_override,
6569            'secret_store_id': self.secret_store_id,
6570            'server_name': self.server_name,
6571            'tags': self.tags,
6572            'username': self.username,
6573        }
#  
@classmethod
def from_dict(cls, d):
View Source
6575    @classmethod
6576    def from_dict(cls, d):
6577        return cls(
6578            certificate_authority=d.get('certificate_authority'),
6579            client_certificate=d.get('client_certificate'),
6580            client_key=d.get('client_key'),
6581            database=d.get('database'),
6582            egress_filter=d.get('egress_filter'),
6583            healthy=d.get('healthy'),
6584            hostname=d.get('hostname'),
6585            id=d.get('id'),
6586            name=d.get('name'),
6587            password=d.get('password'),
6588            port=d.get('port'),
6589            port_override=d.get('port_override'),
6590            secret_store_id=d.get('secret_store_id'),
6591            server_name=d.get('server_name'),
6592            tags=d.get('tags'),
6593            username=d.get('username'),
6594        )
#   class MTLSPostgres:
View Source
6597class MTLSPostgres:
6598    '''
6599
6600    '''
6601    __slots__ = [
6602        'certificate_authority',
6603        'client_certificate',
6604        'client_key',
6605        'database',
6606        'egress_filter',
6607        'healthy',
6608        'hostname',
6609        'id',
6610        'name',
6611        'override_database',
6612        'password',
6613        'port',
6614        'port_override',
6615        'secret_store_id',
6616        'server_name',
6617        'tags',
6618        'username',
6619    ]
6620
6621    def __init__(
6622        self,
6623        certificate_authority=None,
6624        client_certificate=None,
6625        client_key=None,
6626        database=None,
6627        egress_filter=None,
6628        healthy=None,
6629        hostname=None,
6630        id=None,
6631        name=None,
6632        override_database=None,
6633        password=None,
6634        port=None,
6635        port_override=None,
6636        secret_store_id=None,
6637        server_name=None,
6638        tags=None,
6639        username=None,
6640    ):
6641        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6642        '''
6643
6644        '''
6645        self.client_certificate = client_certificate if client_certificate is not None else ''
6646        '''
6647
6648        '''
6649        self.client_key = client_key if client_key is not None else ''
6650        '''
6651
6652        '''
6653        self.database = database if database is not None else ''
6654        '''
6655
6656        '''
6657        self.egress_filter = egress_filter if egress_filter is not None else ''
6658        '''
6659         A filter applied to the routing logic to pin datasource to nodes.
6660        '''
6661        self.healthy = healthy if healthy is not None else False
6662        '''
6663         True if the datasource is reachable and the credentials are valid.
6664        '''
6665        self.hostname = hostname if hostname is not None else ''
6666        '''
6667
6668        '''
6669        self.id = id if id is not None else ''
6670        '''
6671         Unique identifier of the Resource.
6672        '''
6673        self.name = name if name is not None else ''
6674        '''
6675         Unique human-readable name of the Resource.
6676        '''
6677        self.override_database = override_database if override_database is not None else False
6678        '''
6679
6680        '''
6681        self.password = password if password is not None else ''
6682        '''
6683
6684        '''
6685        self.port = port if port is not None else 0
6686        '''
6687
6688        '''
6689        self.port_override = port_override if port_override is not None else 0
6690        '''
6691
6692        '''
6693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6694        '''
6695         ID of the secret store containing credentials for this resource, if any.
6696        '''
6697        self.server_name = server_name if server_name is not None else ''
6698        '''
6699
6700        '''
6701        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6702        '''
6703         Tags is a map of key, value pairs.
6704        '''
6705        self.username = username if username is not None else ''
6706        '''
6707
6708        '''
6709
6710    def __repr__(self):
6711        return '<sdm.MTLSPostgres ' + \
6712            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6713            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6714            'client_key: ' + repr(self.client_key) + ' ' +\
6715            'database: ' + repr(self.database) + ' ' +\
6716            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6717            'healthy: ' + repr(self.healthy) + ' ' +\
6718            'hostname: ' + repr(self.hostname) + ' ' +\
6719            'id: ' + repr(self.id) + ' ' +\
6720            'name: ' + repr(self.name) + ' ' +\
6721            'override_database: ' + repr(self.override_database) + ' ' +\
6722            'password: ' + repr(self.password) + ' ' +\
6723            'port: ' + repr(self.port) + ' ' +\
6724            'port_override: ' + repr(self.port_override) + ' ' +\
6725            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6726            'server_name: ' + repr(self.server_name) + ' ' +\
6727            'tags: ' + repr(self.tags) + ' ' +\
6728            'username: ' + repr(self.username) + ' ' +\
6729            '>'
6730
6731    def to_dict(self):
6732        return {
6733            'certificate_authority': self.certificate_authority,
6734            'client_certificate': self.client_certificate,
6735            'client_key': self.client_key,
6736            'database': self.database,
6737            'egress_filter': self.egress_filter,
6738            'healthy': self.healthy,
6739            'hostname': self.hostname,
6740            'id': self.id,
6741            'name': self.name,
6742            'override_database': self.override_database,
6743            'password': self.password,
6744            'port': self.port,
6745            'port_override': self.port_override,
6746            'secret_store_id': self.secret_store_id,
6747            'server_name': self.server_name,
6748            'tags': self.tags,
6749            'username': self.username,
6750        }
6751
6752    @classmethod
6753    def from_dict(cls, d):
6754        return cls(
6755            certificate_authority=d.get('certificate_authority'),
6756            client_certificate=d.get('client_certificate'),
6757            client_key=d.get('client_key'),
6758            database=d.get('database'),
6759            egress_filter=d.get('egress_filter'),
6760            healthy=d.get('healthy'),
6761            hostname=d.get('hostname'),
6762            id=d.get('id'),
6763            name=d.get('name'),
6764            override_database=d.get('override_database'),
6765            password=d.get('password'),
6766            port=d.get('port'),
6767            port_override=d.get('port_override'),
6768            secret_store_id=d.get('secret_store_id'),
6769            server_name=d.get('server_name'),
6770            tags=d.get('tags'),
6771            username=d.get('username'),
6772        )
#   MTLSPostgres( certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None )
View Source
6621    def __init__(
6622        self,
6623        certificate_authority=None,
6624        client_certificate=None,
6625        client_key=None,
6626        database=None,
6627        egress_filter=None,
6628        healthy=None,
6629        hostname=None,
6630        id=None,
6631        name=None,
6632        override_database=None,
6633        password=None,
6634        port=None,
6635        port_override=None,
6636        secret_store_id=None,
6637        server_name=None,
6638        tags=None,
6639        username=None,
6640    ):
6641        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6642        '''
6643
6644        '''
6645        self.client_certificate = client_certificate if client_certificate is not None else ''
6646        '''
6647
6648        '''
6649        self.client_key = client_key if client_key is not None else ''
6650        '''
6651
6652        '''
6653        self.database = database if database is not None else ''
6654        '''
6655
6656        '''
6657        self.egress_filter = egress_filter if egress_filter is not None else ''
6658        '''
6659         A filter applied to the routing logic to pin datasource to nodes.
6660        '''
6661        self.healthy = healthy if healthy is not None else False
6662        '''
6663         True if the datasource is reachable and the credentials are valid.
6664        '''
6665        self.hostname = hostname if hostname is not None else ''
6666        '''
6667
6668        '''
6669        self.id = id if id is not None else ''
6670        '''
6671         Unique identifier of the Resource.
6672        '''
6673        self.name = name if name is not None else ''
6674        '''
6675         Unique human-readable name of the Resource.
6676        '''
6677        self.override_database = override_database if override_database is not None else False
6678        '''
6679
6680        '''
6681        self.password = password if password is not None else ''
6682        '''
6683
6684        '''
6685        self.port = port if port is not None else 0
6686        '''
6687
6688        '''
6689        self.port_override = port_override if port_override is not None else 0
6690        '''
6691
6692        '''
6693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6694        '''
6695         ID of the secret store containing credentials for this resource, if any.
6696        '''
6697        self.server_name = server_name if server_name is not None else ''
6698        '''
6699
6700        '''
6701        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6702        '''
6703         Tags is a map of key, value pairs.
6704        '''
6705        self.username = username if username is not None else ''
6706        '''
6707
6708        '''
#   certificate_authority
#   client_certificate
#   client_key
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   server_name
#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
6731    def to_dict(self):
6732        return {
6733            'certificate_authority': self.certificate_authority,
6734            'client_certificate': self.client_certificate,
6735            'client_key': self.client_key,
6736            'database': self.database,
6737            'egress_filter': self.egress_filter,
6738            'healthy': self.healthy,
6739            'hostname': self.hostname,
6740            'id': self.id,
6741            'name': self.name,
6742            'override_database': self.override_database,
6743            'password': self.password,
6744            'port': self.port,
6745            'port_override': self.port_override,
6746            'secret_store_id': self.secret_store_id,
6747            'server_name': self.server_name,
6748            'tags': self.tags,
6749            'username': self.username,
6750        }
#  
@classmethod
def from_dict(cls, d):
View Source
6752    @classmethod
6753    def from_dict(cls, d):
6754        return cls(
6755            certificate_authority=d.get('certificate_authority'),
6756            client_certificate=d.get('client_certificate'),
6757            client_key=d.get('client_key'),
6758            database=d.get('database'),
6759            egress_filter=d.get('egress_filter'),
6760            healthy=d.get('healthy'),
6761            hostname=d.get('hostname'),
6762            id=d.get('id'),
6763            name=d.get('name'),
6764            override_database=d.get('override_database'),
6765            password=d.get('password'),
6766            port=d.get('port'),
6767            port_override=d.get('port_override'),
6768            secret_store_id=d.get('secret_store_id'),
6769            server_name=d.get('server_name'),
6770            tags=d.get('tags'),
6771            username=d.get('username'),
6772        )
#   class Maria:
View Source
6775class Maria:
6776    '''
6777
6778    '''
6779    __slots__ = [
6780        'database',
6781        'egress_filter',
6782        'healthy',
6783        'hostname',
6784        'id',
6785        'name',
6786        'password',
6787        'port',
6788        'port_override',
6789        'secret_store_id',
6790        'tags',
6791        'username',
6792    ]
6793
6794    def __init__(
6795        self,
6796        database=None,
6797        egress_filter=None,
6798        healthy=None,
6799        hostname=None,
6800        id=None,
6801        name=None,
6802        password=None,
6803        port=None,
6804        port_override=None,
6805        secret_store_id=None,
6806        tags=None,
6807        username=None,
6808    ):
6809        self.database = database if database is not None else ''
6810        '''
6811
6812        '''
6813        self.egress_filter = egress_filter if egress_filter is not None else ''
6814        '''
6815         A filter applied to the routing logic to pin datasource to nodes.
6816        '''
6817        self.healthy = healthy if healthy is not None else False
6818        '''
6819         True if the datasource is reachable and the credentials are valid.
6820        '''
6821        self.hostname = hostname if hostname is not None else ''
6822        '''
6823
6824        '''
6825        self.id = id if id is not None else ''
6826        '''
6827         Unique identifier of the Resource.
6828        '''
6829        self.name = name if name is not None else ''
6830        '''
6831         Unique human-readable name of the Resource.
6832        '''
6833        self.password = password if password is not None else ''
6834        '''
6835
6836        '''
6837        self.port = port if port is not None else 0
6838        '''
6839
6840        '''
6841        self.port_override = port_override if port_override is not None else 0
6842        '''
6843
6844        '''
6845        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6846        '''
6847         ID of the secret store containing credentials for this resource, if any.
6848        '''
6849        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6850        '''
6851         Tags is a map of key, value pairs.
6852        '''
6853        self.username = username if username is not None else ''
6854        '''
6855
6856        '''
6857
6858    def __repr__(self):
6859        return '<sdm.Maria ' + \
6860            'database: ' + repr(self.database) + ' ' +\
6861            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6862            'healthy: ' + repr(self.healthy) + ' ' +\
6863            'hostname: ' + repr(self.hostname) + ' ' +\
6864            'id: ' + repr(self.id) + ' ' +\
6865            'name: ' + repr(self.name) + ' ' +\
6866            'password: ' + repr(self.password) + ' ' +\
6867            'port: ' + repr(self.port) + ' ' +\
6868            'port_override: ' + repr(self.port_override) + ' ' +\
6869            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6870            'tags: ' + repr(self.tags) + ' ' +\
6871            'username: ' + repr(self.username) + ' ' +\
6872            '>'
6873
6874    def to_dict(self):
6875        return {
6876            'database': self.database,
6877            'egress_filter': self.egress_filter,
6878            'healthy': self.healthy,
6879            'hostname': self.hostname,
6880            'id': self.id,
6881            'name': self.name,
6882            'password': self.password,
6883            'port': self.port,
6884            'port_override': self.port_override,
6885            'secret_store_id': self.secret_store_id,
6886            'tags': self.tags,
6887            'username': self.username,
6888        }
6889
6890    @classmethod
6891    def from_dict(cls, d):
6892        return cls(
6893            database=d.get('database'),
6894            egress_filter=d.get('egress_filter'),
6895            healthy=d.get('healthy'),
6896            hostname=d.get('hostname'),
6897            id=d.get('id'),
6898            name=d.get('name'),
6899            password=d.get('password'),
6900            port=d.get('port'),
6901            port_override=d.get('port_override'),
6902            secret_store_id=d.get('secret_store_id'),
6903            tags=d.get('tags'),
6904            username=d.get('username'),
6905        )
#   Maria( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
6794    def __init__(
6795        self,
6796        database=None,
6797        egress_filter=None,
6798        healthy=None,
6799        hostname=None,
6800        id=None,
6801        name=None,
6802        password=None,
6803        port=None,
6804        port_override=None,
6805        secret_store_id=None,
6806        tags=None,
6807        username=None,
6808    ):
6809        self.database = database if database is not None else ''
6810        '''
6811
6812        '''
6813        self.egress_filter = egress_filter if egress_filter is not None else ''
6814        '''
6815         A filter applied to the routing logic to pin datasource to nodes.
6816        '''
6817        self.healthy = healthy if healthy is not None else False
6818        '''
6819         True if the datasource is reachable and the credentials are valid.
6820        '''
6821        self.hostname = hostname if hostname is not None else ''
6822        '''
6823
6824        '''
6825        self.id = id if id is not None else ''
6826        '''
6827         Unique identifier of the Resource.
6828        '''
6829        self.name = name if name is not None else ''
6830        '''
6831         Unique human-readable name of the Resource.
6832        '''
6833        self.password = password if password is not None else ''
6834        '''
6835
6836        '''
6837        self.port = port if port is not None else 0
6838        '''
6839
6840        '''
6841        self.port_override = port_override if port_override is not None else 0
6842        '''
6843
6844        '''
6845        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6846        '''
6847         ID of the secret store containing credentials for this resource, if any.
6848        '''
6849        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6850        '''
6851         Tags is a map of key, value pairs.
6852        '''
6853        self.username = username if username is not None else ''
6854        '''
6855
6856        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
6874    def to_dict(self):
6875        return {
6876            'database': self.database,
6877            'egress_filter': self.egress_filter,
6878            'healthy': self.healthy,
6879            'hostname': self.hostname,
6880            'id': self.id,
6881            'name': self.name,
6882            'password': self.password,
6883            'port': self.port,
6884            'port_override': self.port_override,
6885            'secret_store_id': self.secret_store_id,
6886            'tags': self.tags,
6887            'username': self.username,
6888        }
#  
@classmethod
def from_dict(cls, d):
View Source
6890    @classmethod
6891    def from_dict(cls, d):
6892        return cls(
6893            database=d.get('database'),
6894            egress_filter=d.get('egress_filter'),
6895            healthy=d.get('healthy'),
6896            hostname=d.get('hostname'),
6897            id=d.get('id'),
6898            name=d.get('name'),
6899            password=d.get('password'),
6900            port=d.get('port'),
6901            port_override=d.get('port_override'),
6902            secret_store_id=d.get('secret_store_id'),
6903            tags=d.get('tags'),
6904            username=d.get('username'),
6905        )
#   class Memcached:
View Source
6908class Memcached:
6909    '''
6910
6911    '''
6912    __slots__ = [
6913        'egress_filter',
6914        'healthy',
6915        'hostname',
6916        'id',
6917        'name',
6918        'port',
6919        'port_override',
6920        'secret_store_id',
6921        'tags',
6922    ]
6923
6924    def __init__(
6925        self,
6926        egress_filter=None,
6927        healthy=None,
6928        hostname=None,
6929        id=None,
6930        name=None,
6931        port=None,
6932        port_override=None,
6933        secret_store_id=None,
6934        tags=None,
6935    ):
6936        self.egress_filter = egress_filter if egress_filter is not None else ''
6937        '''
6938         A filter applied to the routing logic to pin datasource to nodes.
6939        '''
6940        self.healthy = healthy if healthy is not None else False
6941        '''
6942         True if the datasource is reachable and the credentials are valid.
6943        '''
6944        self.hostname = hostname if hostname is not None else ''
6945        '''
6946
6947        '''
6948        self.id = id if id is not None else ''
6949        '''
6950         Unique identifier of the Resource.
6951        '''
6952        self.name = name if name is not None else ''
6953        '''
6954         Unique human-readable name of the Resource.
6955        '''
6956        self.port = port if port is not None else 0
6957        '''
6958
6959        '''
6960        self.port_override = port_override if port_override is not None else 0
6961        '''
6962
6963        '''
6964        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6965        '''
6966         ID of the secret store containing credentials for this resource, if any.
6967        '''
6968        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6969        '''
6970         Tags is a map of key, value pairs.
6971        '''
6972
6973    def __repr__(self):
6974        return '<sdm.Memcached ' + \
6975            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6976            'healthy: ' + repr(self.healthy) + ' ' +\
6977            'hostname: ' + repr(self.hostname) + ' ' +\
6978            'id: ' + repr(self.id) + ' ' +\
6979            'name: ' + repr(self.name) + ' ' +\
6980            'port: ' + repr(self.port) + ' ' +\
6981            'port_override: ' + repr(self.port_override) + ' ' +\
6982            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6983            'tags: ' + repr(self.tags) + ' ' +\
6984            '>'
6985
6986    def to_dict(self):
6987        return {
6988            'egress_filter': self.egress_filter,
6989            'healthy': self.healthy,
6990            'hostname': self.hostname,
6991            'id': self.id,
6992            'name': self.name,
6993            'port': self.port,
6994            'port_override': self.port_override,
6995            'secret_store_id': self.secret_store_id,
6996            'tags': self.tags,
6997        }
6998
6999    @classmethod
7000    def from_dict(cls, d):
7001        return cls(
7002            egress_filter=d.get('egress_filter'),
7003            healthy=d.get('healthy'),
7004            hostname=d.get('hostname'),
7005            id=d.get('id'),
7006            name=d.get('name'),
7007            port=d.get('port'),
7008            port_override=d.get('port_override'),
7009            secret_store_id=d.get('secret_store_id'),
7010            tags=d.get('tags'),
7011        )
#   Memcached( egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
6924    def __init__(
6925        self,
6926        egress_filter=None,
6927        healthy=None,
6928        hostname=None,
6929        id=None,
6930        name=None,
6931        port=None,
6932        port_override=None,
6933        secret_store_id=None,
6934        tags=None,
6935    ):
6936        self.egress_filter = egress_filter if egress_filter is not None else ''
6937        '''
6938         A filter applied to the routing logic to pin datasource to nodes.
6939        '''
6940        self.healthy = healthy if healthy is not None else False
6941        '''
6942         True if the datasource is reachable and the credentials are valid.
6943        '''
6944        self.hostname = hostname if hostname is not None else ''
6945        '''
6946
6947        '''
6948        self.id = id if id is not None else ''
6949        '''
6950         Unique identifier of the Resource.
6951        '''
6952        self.name = name if name is not None else ''
6953        '''
6954         Unique human-readable name of the Resource.
6955        '''
6956        self.port = port if port is not None else 0
6957        '''
6958
6959        '''
6960        self.port_override = port_override if port_override is not None else 0
6961        '''
6962
6963        '''
6964        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6965        '''
6966         ID of the secret store containing credentials for this resource, if any.
6967        '''
6968        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6969        '''
6970         Tags is a map of key, value pairs.
6971        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
6986    def to_dict(self):
6987        return {
6988            'egress_filter': self.egress_filter,
6989            'healthy': self.healthy,
6990            'hostname': self.hostname,
6991            'id': self.id,
6992            'name': self.name,
6993            'port': self.port,
6994            'port_override': self.port_override,
6995            'secret_store_id': self.secret_store_id,
6996            'tags': self.tags,
6997        }
#  
@classmethod
def from_dict(cls, d):
View Source
6999    @classmethod
7000    def from_dict(cls, d):
7001        return cls(
7002            egress_filter=d.get('egress_filter'),
7003            healthy=d.get('healthy'),
7004            hostname=d.get('hostname'),
7005            id=d.get('id'),
7006            name=d.get('name'),
7007            port=d.get('port'),
7008            port_override=d.get('port_override'),
7009            secret_store_id=d.get('secret_store_id'),
7010            tags=d.get('tags'),
7011        )
#   class Memsql:
View Source
7014class Memsql:
7015    '''
7016
7017    '''
7018    __slots__ = [
7019        'database',
7020        'egress_filter',
7021        'healthy',
7022        'hostname',
7023        'id',
7024        'name',
7025        'password',
7026        'port',
7027        'port_override',
7028        'secret_store_id',
7029        'tags',
7030        'username',
7031    ]
7032
7033    def __init__(
7034        self,
7035        database=None,
7036        egress_filter=None,
7037        healthy=None,
7038        hostname=None,
7039        id=None,
7040        name=None,
7041        password=None,
7042        port=None,
7043        port_override=None,
7044        secret_store_id=None,
7045        tags=None,
7046        username=None,
7047    ):
7048        self.database = database if database is not None else ''
7049        '''
7050
7051        '''
7052        self.egress_filter = egress_filter if egress_filter is not None else ''
7053        '''
7054         A filter applied to the routing logic to pin datasource to nodes.
7055        '''
7056        self.healthy = healthy if healthy is not None else False
7057        '''
7058         True if the datasource is reachable and the credentials are valid.
7059        '''
7060        self.hostname = hostname if hostname is not None else ''
7061        '''
7062
7063        '''
7064        self.id = id if id is not None else ''
7065        '''
7066         Unique identifier of the Resource.
7067        '''
7068        self.name = name if name is not None else ''
7069        '''
7070         Unique human-readable name of the Resource.
7071        '''
7072        self.password = password if password is not None else ''
7073        '''
7074
7075        '''
7076        self.port = port if port is not None else 0
7077        '''
7078
7079        '''
7080        self.port_override = port_override if port_override is not None else 0
7081        '''
7082
7083        '''
7084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7085        '''
7086         ID of the secret store containing credentials for this resource, if any.
7087        '''
7088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7089        '''
7090         Tags is a map of key, value pairs.
7091        '''
7092        self.username = username if username is not None else ''
7093        '''
7094
7095        '''
7096
7097    def __repr__(self):
7098        return '<sdm.Memsql ' + \
7099            'database: ' + repr(self.database) + ' ' +\
7100            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7101            'healthy: ' + repr(self.healthy) + ' ' +\
7102            'hostname: ' + repr(self.hostname) + ' ' +\
7103            'id: ' + repr(self.id) + ' ' +\
7104            'name: ' + repr(self.name) + ' ' +\
7105            'password: ' + repr(self.password) + ' ' +\
7106            'port: ' + repr(self.port) + ' ' +\
7107            'port_override: ' + repr(self.port_override) + ' ' +\
7108            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7109            'tags: ' + repr(self.tags) + ' ' +\
7110            'username: ' + repr(self.username) + ' ' +\
7111            '>'
7112
7113    def to_dict(self):
7114        return {
7115            'database': self.database,
7116            'egress_filter': self.egress_filter,
7117            'healthy': self.healthy,
7118            'hostname': self.hostname,
7119            'id': self.id,
7120            'name': self.name,
7121            'password': self.password,
7122            'port': self.port,
7123            'port_override': self.port_override,
7124            'secret_store_id': self.secret_store_id,
7125            'tags': self.tags,
7126            'username': self.username,
7127        }
7128
7129    @classmethod
7130    def from_dict(cls, d):
7131        return cls(
7132            database=d.get('database'),
7133            egress_filter=d.get('egress_filter'),
7134            healthy=d.get('healthy'),
7135            hostname=d.get('hostname'),
7136            id=d.get('id'),
7137            name=d.get('name'),
7138            password=d.get('password'),
7139            port=d.get('port'),
7140            port_override=d.get('port_override'),
7141            secret_store_id=d.get('secret_store_id'),
7142            tags=d.get('tags'),
7143            username=d.get('username'),
7144        )
#   Memsql( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
7033    def __init__(
7034        self,
7035        database=None,
7036        egress_filter=None,
7037        healthy=None,
7038        hostname=None,
7039        id=None,
7040        name=None,
7041        password=None,
7042        port=None,
7043        port_override=None,
7044        secret_store_id=None,
7045        tags=None,
7046        username=None,
7047    ):
7048        self.database = database if database is not None else ''
7049        '''
7050
7051        '''
7052        self.egress_filter = egress_filter if egress_filter is not None else ''
7053        '''
7054         A filter applied to the routing logic to pin datasource to nodes.
7055        '''
7056        self.healthy = healthy if healthy is not None else False
7057        '''
7058         True if the datasource is reachable and the credentials are valid.
7059        '''
7060        self.hostname = hostname if hostname is not None else ''
7061        '''
7062
7063        '''
7064        self.id = id if id is not None else ''
7065        '''
7066         Unique identifier of the Resource.
7067        '''
7068        self.name = name if name is not None else ''
7069        '''
7070         Unique human-readable name of the Resource.
7071        '''
7072        self.password = password if password is not None else ''
7073        '''
7074
7075        '''
7076        self.port = port if port is not None else 0
7077        '''
7078
7079        '''
7080        self.port_override = port_override if port_override is not None else 0
7081        '''
7082
7083        '''
7084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7085        '''
7086         ID of the secret store containing credentials for this resource, if any.
7087        '''
7088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7089        '''
7090         Tags is a map of key, value pairs.
7091        '''
7092        self.username = username if username is not None else ''
7093        '''
7094
7095        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
7113    def to_dict(self):
7114        return {
7115            'database': self.database,
7116            'egress_filter': self.egress_filter,
7117            'healthy': self.healthy,
7118            'hostname': self.hostname,
7119            'id': self.id,
7120            'name': self.name,
7121            'password': self.password,
7122            'port': self.port,
7123            'port_override': self.port_override,
7124            'secret_store_id': self.secret_store_id,
7125            'tags': self.tags,
7126            'username': self.username,
7127        }
#  
@classmethod
def from_dict(cls, d):
View Source
7129    @classmethod
7130    def from_dict(cls, d):
7131        return cls(
7132            database=d.get('database'),
7133            egress_filter=d.get('egress_filter'),
7134            healthy=d.get('healthy'),
7135            hostname=d.get('hostname'),
7136            id=d.get('id'),
7137            name=d.get('name'),
7138            password=d.get('password'),
7139            port=d.get('port'),
7140            port_override=d.get('port_override'),
7141            secret_store_id=d.get('secret_store_id'),
7142            tags=d.get('tags'),
7143            username=d.get('username'),
7144        )
#   class MongoHost:
View Source
7147class MongoHost:
7148    '''
7149
7150    '''
7151    __slots__ = [
7152        'auth_database',
7153        'egress_filter',
7154        'healthy',
7155        'hostname',
7156        'id',
7157        'name',
7158        'password',
7159        'port',
7160        'port_override',
7161        'secret_store_id',
7162        'tags',
7163        'tls_required',
7164        'username',
7165    ]
7166
7167    def __init__(
7168        self,
7169        auth_database=None,
7170        egress_filter=None,
7171        healthy=None,
7172        hostname=None,
7173        id=None,
7174        name=None,
7175        password=None,
7176        port=None,
7177        port_override=None,
7178        secret_store_id=None,
7179        tags=None,
7180        tls_required=None,
7181        username=None,
7182    ):
7183        self.auth_database = auth_database if auth_database is not None else ''
7184        '''
7185
7186        '''
7187        self.egress_filter = egress_filter if egress_filter is not None else ''
7188        '''
7189         A filter applied to the routing logic to pin datasource to nodes.
7190        '''
7191        self.healthy = healthy if healthy is not None else False
7192        '''
7193         True if the datasource is reachable and the credentials are valid.
7194        '''
7195        self.hostname = hostname if hostname is not None else ''
7196        '''
7197
7198        '''
7199        self.id = id if id is not None else ''
7200        '''
7201         Unique identifier of the Resource.
7202        '''
7203        self.name = name if name is not None else ''
7204        '''
7205         Unique human-readable name of the Resource.
7206        '''
7207        self.password = password if password is not None else ''
7208        '''
7209
7210        '''
7211        self.port = port if port is not None else 0
7212        '''
7213
7214        '''
7215        self.port_override = port_override if port_override is not None else 0
7216        '''
7217
7218        '''
7219        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7220        '''
7221         ID of the secret store containing credentials for this resource, if any.
7222        '''
7223        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7224        '''
7225         Tags is a map of key, value pairs.
7226        '''
7227        self.tls_required = tls_required if tls_required is not None else False
7228        '''
7229
7230        '''
7231        self.username = username if username is not None else ''
7232        '''
7233
7234        '''
7235
7236    def __repr__(self):
7237        return '<sdm.MongoHost ' + \
7238            'auth_database: ' + repr(self.auth_database) + ' ' +\
7239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7240            'healthy: ' + repr(self.healthy) + ' ' +\
7241            'hostname: ' + repr(self.hostname) + ' ' +\
7242            'id: ' + repr(self.id) + ' ' +\
7243            'name: ' + repr(self.name) + ' ' +\
7244            'password: ' + repr(self.password) + ' ' +\
7245            'port: ' + repr(self.port) + ' ' +\
7246            'port_override: ' + repr(self.port_override) + ' ' +\
7247            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7248            'tags: ' + repr(self.tags) + ' ' +\
7249            'tls_required: ' + repr(self.tls_required) + ' ' +\
7250            'username: ' + repr(self.username) + ' ' +\
7251            '>'
7252
7253    def to_dict(self):
7254        return {
7255            'auth_database': self.auth_database,
7256            'egress_filter': self.egress_filter,
7257            'healthy': self.healthy,
7258            'hostname': self.hostname,
7259            'id': self.id,
7260            'name': self.name,
7261            'password': self.password,
7262            'port': self.port,
7263            'port_override': self.port_override,
7264            'secret_store_id': self.secret_store_id,
7265            'tags': self.tags,
7266            'tls_required': self.tls_required,
7267            'username': self.username,
7268        }
7269
7270    @classmethod
7271    def from_dict(cls, d):
7272        return cls(
7273            auth_database=d.get('auth_database'),
7274            egress_filter=d.get('egress_filter'),
7275            healthy=d.get('healthy'),
7276            hostname=d.get('hostname'),
7277            id=d.get('id'),
7278            name=d.get('name'),
7279            password=d.get('password'),
7280            port=d.get('port'),
7281            port_override=d.get('port_override'),
7282            secret_store_id=d.get('secret_store_id'),
7283            tags=d.get('tags'),
7284            tls_required=d.get('tls_required'),
7285            username=d.get('username'),
7286        )
#   MongoHost( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
7167    def __init__(
7168        self,
7169        auth_database=None,
7170        egress_filter=None,
7171        healthy=None,
7172        hostname=None,
7173        id=None,
7174        name=None,
7175        password=None,
7176        port=None,
7177        port_override=None,
7178        secret_store_id=None,
7179        tags=None,
7180        tls_required=None,
7181        username=None,
7182    ):
7183        self.auth_database = auth_database if auth_database is not None else ''
7184        '''
7185
7186        '''
7187        self.egress_filter = egress_filter if egress_filter is not None else ''
7188        '''
7189         A filter applied to the routing logic to pin datasource to nodes.
7190        '''
7191        self.healthy = healthy if healthy is not None else False
7192        '''
7193         True if the datasource is reachable and the credentials are valid.
7194        '''
7195        self.hostname = hostname if hostname is not None else ''
7196        '''
7197
7198        '''
7199        self.id = id if id is not None else ''
7200        '''
7201         Unique identifier of the Resource.
7202        '''
7203        self.name = name if name is not None else ''
7204        '''
7205         Unique human-readable name of the Resource.
7206        '''
7207        self.password = password if password is not None else ''
7208        '''
7209
7210        '''
7211        self.port = port if port is not None else 0
7212        '''
7213
7214        '''
7215        self.port_override = port_override if port_override is not None else 0
7216        '''
7217
7218        '''
7219        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7220        '''
7221         ID of the secret store containing credentials for this resource, if any.
7222        '''
7223        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7224        '''
7225         Tags is a map of key, value pairs.
7226        '''
7227        self.tls_required = tls_required if tls_required is not None else False
7228        '''
7229
7230        '''
7231        self.username = username if username is not None else ''
7232        '''
7233
7234        '''
#   auth_database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
7253    def to_dict(self):
7254        return {
7255            'auth_database': self.auth_database,
7256            'egress_filter': self.egress_filter,
7257            'healthy': self.healthy,
7258            'hostname': self.hostname,
7259            'id': self.id,
7260            'name': self.name,
7261            'password': self.password,
7262            'port': self.port,
7263            'port_override': self.port_override,
7264            'secret_store_id': self.secret_store_id,
7265            'tags': self.tags,
7266            'tls_required': self.tls_required,
7267            'username': self.username,
7268        }
#  
@classmethod
def from_dict(cls, d):
View Source
7270    @classmethod
7271    def from_dict(cls, d):
7272        return cls(
7273            auth_database=d.get('auth_database'),
7274            egress_filter=d.get('egress_filter'),
7275            healthy=d.get('healthy'),
7276            hostname=d.get('hostname'),
7277            id=d.get('id'),
7278            name=d.get('name'),
7279            password=d.get('password'),
7280            port=d.get('port'),
7281            port_override=d.get('port_override'),
7282            secret_store_id=d.get('secret_store_id'),
7283            tags=d.get('tags'),
7284            tls_required=d.get('tls_required'),
7285            username=d.get('username'),
7286        )
#   class MongoLegacyHost:
View Source
7289class MongoLegacyHost:
7290    '''
7291
7292    '''
7293    __slots__ = [
7294        'auth_database',
7295        'egress_filter',
7296        'healthy',
7297        'hostname',
7298        'id',
7299        'name',
7300        'password',
7301        'port',
7302        'port_override',
7303        'replica_set',
7304        'secret_store_id',
7305        'tags',
7306        'tls_required',
7307        'username',
7308    ]
7309
7310    def __init__(
7311        self,
7312        auth_database=None,
7313        egress_filter=None,
7314        healthy=None,
7315        hostname=None,
7316        id=None,
7317        name=None,
7318        password=None,
7319        port=None,
7320        port_override=None,
7321        replica_set=None,
7322        secret_store_id=None,
7323        tags=None,
7324        tls_required=None,
7325        username=None,
7326    ):
7327        self.auth_database = auth_database if auth_database is not None else ''
7328        '''
7329
7330        '''
7331        self.egress_filter = egress_filter if egress_filter is not None else ''
7332        '''
7333         A filter applied to the routing logic to pin datasource to nodes.
7334        '''
7335        self.healthy = healthy if healthy is not None else False
7336        '''
7337         True if the datasource is reachable and the credentials are valid.
7338        '''
7339        self.hostname = hostname if hostname is not None else ''
7340        '''
7341
7342        '''
7343        self.id = id if id is not None else ''
7344        '''
7345         Unique identifier of the Resource.
7346        '''
7347        self.name = name if name is not None else ''
7348        '''
7349         Unique human-readable name of the Resource.
7350        '''
7351        self.password = password if password is not None else ''
7352        '''
7353
7354        '''
7355        self.port = port if port is not None else 0
7356        '''
7357
7358        '''
7359        self.port_override = port_override if port_override is not None else 0
7360        '''
7361
7362        '''
7363        self.replica_set = replica_set if replica_set is not None else ''
7364        '''
7365
7366        '''
7367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7368        '''
7369         ID of the secret store containing credentials for this resource, if any.
7370        '''
7371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7372        '''
7373         Tags is a map of key, value pairs.
7374        '''
7375        self.tls_required = tls_required if tls_required is not None else False
7376        '''
7377
7378        '''
7379        self.username = username if username is not None else ''
7380        '''
7381
7382        '''
7383
7384    def __repr__(self):
7385        return '<sdm.MongoLegacyHost ' + \
7386            'auth_database: ' + repr(self.auth_database) + ' ' +\
7387            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7388            'healthy: ' + repr(self.healthy) + ' ' +\
7389            'hostname: ' + repr(self.hostname) + ' ' +\
7390            'id: ' + repr(self.id) + ' ' +\
7391            'name: ' + repr(self.name) + ' ' +\
7392            'password: ' + repr(self.password) + ' ' +\
7393            'port: ' + repr(self.port) + ' ' +\
7394            'port_override: ' + repr(self.port_override) + ' ' +\
7395            'replica_set: ' + repr(self.replica_set) + ' ' +\
7396            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7397            'tags: ' + repr(self.tags) + ' ' +\
7398            'tls_required: ' + repr(self.tls_required) + ' ' +\
7399            'username: ' + repr(self.username) + ' ' +\
7400            '>'
7401
7402    def to_dict(self):
7403        return {
7404            'auth_database': self.auth_database,
7405            'egress_filter': self.egress_filter,
7406            'healthy': self.healthy,
7407            'hostname': self.hostname,
7408            'id': self.id,
7409            'name': self.name,
7410            'password': self.password,
7411            'port': self.port,
7412            'port_override': self.port_override,
7413            'replica_set': self.replica_set,
7414            'secret_store_id': self.secret_store_id,
7415            'tags': self.tags,
7416            'tls_required': self.tls_required,
7417            'username': self.username,
7418        }
7419
7420    @classmethod
7421    def from_dict(cls, d):
7422        return cls(
7423            auth_database=d.get('auth_database'),
7424            egress_filter=d.get('egress_filter'),
7425            healthy=d.get('healthy'),
7426            hostname=d.get('hostname'),
7427            id=d.get('id'),
7428            name=d.get('name'),
7429            password=d.get('password'),
7430            port=d.get('port'),
7431            port_override=d.get('port_override'),
7432            replica_set=d.get('replica_set'),
7433            secret_store_id=d.get('secret_store_id'),
7434            tags=d.get('tags'),
7435            tls_required=d.get('tls_required'),
7436            username=d.get('username'),
7437        )
#   MongoLegacyHost( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
7310    def __init__(
7311        self,
7312        auth_database=None,
7313        egress_filter=None,
7314        healthy=None,
7315        hostname=None,
7316        id=None,
7317        name=None,
7318        password=None,
7319        port=None,
7320        port_override=None,
7321        replica_set=None,
7322        secret_store_id=None,
7323        tags=None,
7324        tls_required=None,
7325        username=None,
7326    ):
7327        self.auth_database = auth_database if auth_database is not None else ''
7328        '''
7329
7330        '''
7331        self.egress_filter = egress_filter if egress_filter is not None else ''
7332        '''
7333         A filter applied to the routing logic to pin datasource to nodes.
7334        '''
7335        self.healthy = healthy if healthy is not None else False
7336        '''
7337         True if the datasource is reachable and the credentials are valid.
7338        '''
7339        self.hostname = hostname if hostname is not None else ''
7340        '''
7341
7342        '''
7343        self.id = id if id is not None else ''
7344        '''
7345         Unique identifier of the Resource.
7346        '''
7347        self.name = name if name is not None else ''
7348        '''
7349         Unique human-readable name of the Resource.
7350        '''
7351        self.password = password if password is not None else ''
7352        '''
7353
7354        '''
7355        self.port = port if port is not None else 0
7356        '''
7357
7358        '''
7359        self.port_override = port_override if port_override is not None else 0
7360        '''
7361
7362        '''
7363        self.replica_set = replica_set if replica_set is not None else ''
7364        '''
7365
7366        '''
7367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7368        '''
7369         ID of the secret store containing credentials for this resource, if any.
7370        '''
7371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7372        '''
7373         Tags is a map of key, value pairs.
7374        '''
7375        self.tls_required = tls_required if tls_required is not None else False
7376        '''
7377
7378        '''
7379        self.username = username if username is not None else ''
7380        '''
7381
7382        '''
#   auth_database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   replica_set
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
7402    def to_dict(self):
7403        return {
7404            'auth_database': self.auth_database,
7405            'egress_filter': self.egress_filter,
7406            'healthy': self.healthy,
7407            'hostname': self.hostname,
7408            'id': self.id,
7409            'name': self.name,
7410            'password': self.password,
7411            'port': self.port,
7412            'port_override': self.port_override,
7413            'replica_set': self.replica_set,
7414            'secret_store_id': self.secret_store_id,
7415            'tags': self.tags,
7416            'tls_required': self.tls_required,
7417            'username': self.username,
7418        }
#  
@classmethod
def from_dict(cls, d):
View Source
7420    @classmethod
7421    def from_dict(cls, d):
7422        return cls(
7423            auth_database=d.get('auth_database'),
7424            egress_filter=d.get('egress_filter'),
7425            healthy=d.get('healthy'),
7426            hostname=d.get('hostname'),
7427            id=d.get('id'),
7428            name=d.get('name'),
7429            password=d.get('password'),
7430            port=d.get('port'),
7431            port_override=d.get('port_override'),
7432            replica_set=d.get('replica_set'),
7433            secret_store_id=d.get('secret_store_id'),
7434            tags=d.get('tags'),
7435            tls_required=d.get('tls_required'),
7436            username=d.get('username'),
7437        )
#   class MongoLegacyReplicaset:
View Source
7440class MongoLegacyReplicaset:
7441    '''
7442
7443    '''
7444    __slots__ = [
7445        'auth_database',
7446        'connect_to_replica',
7447        'egress_filter',
7448        'healthy',
7449        'hostname',
7450        'id',
7451        'name',
7452        'password',
7453        'port',
7454        'port_override',
7455        'replica_set',
7456        'secret_store_id',
7457        'tags',
7458        'tls_required',
7459        'username',
7460    ]
7461
7462    def __init__(
7463        self,
7464        auth_database=None,
7465        connect_to_replica=None,
7466        egress_filter=None,
7467        healthy=None,
7468        hostname=None,
7469        id=None,
7470        name=None,
7471        password=None,
7472        port=None,
7473        port_override=None,
7474        replica_set=None,
7475        secret_store_id=None,
7476        tags=None,
7477        tls_required=None,
7478        username=None,
7479    ):
7480        self.auth_database = auth_database if auth_database is not None else ''
7481        '''
7482
7483        '''
7484        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7485        '''
7486
7487        '''
7488        self.egress_filter = egress_filter if egress_filter is not None else ''
7489        '''
7490         A filter applied to the routing logic to pin datasource to nodes.
7491        '''
7492        self.healthy = healthy if healthy is not None else False
7493        '''
7494         True if the datasource is reachable and the credentials are valid.
7495        '''
7496        self.hostname = hostname if hostname is not None else ''
7497        '''
7498
7499        '''
7500        self.id = id if id is not None else ''
7501        '''
7502         Unique identifier of the Resource.
7503        '''
7504        self.name = name if name is not None else ''
7505        '''
7506         Unique human-readable name of the Resource.
7507        '''
7508        self.password = password if password is not None else ''
7509        '''
7510
7511        '''
7512        self.port = port if port is not None else 0
7513        '''
7514
7515        '''
7516        self.port_override = port_override if port_override is not None else 0
7517        '''
7518
7519        '''
7520        self.replica_set = replica_set if replica_set is not None else ''
7521        '''
7522
7523        '''
7524        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7525        '''
7526         ID of the secret store containing credentials for this resource, if any.
7527        '''
7528        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7529        '''
7530         Tags is a map of key, value pairs.
7531        '''
7532        self.tls_required = tls_required if tls_required is not None else False
7533        '''
7534
7535        '''
7536        self.username = username if username is not None else ''
7537        '''
7538
7539        '''
7540
7541    def __repr__(self):
7542        return '<sdm.MongoLegacyReplicaset ' + \
7543            'auth_database: ' + repr(self.auth_database) + ' ' +\
7544            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7545            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7546            'healthy: ' + repr(self.healthy) + ' ' +\
7547            'hostname: ' + repr(self.hostname) + ' ' +\
7548            'id: ' + repr(self.id) + ' ' +\
7549            'name: ' + repr(self.name) + ' ' +\
7550            'password: ' + repr(self.password) + ' ' +\
7551            'port: ' + repr(self.port) + ' ' +\
7552            'port_override: ' + repr(self.port_override) + ' ' +\
7553            'replica_set: ' + repr(self.replica_set) + ' ' +\
7554            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7555            'tags: ' + repr(self.tags) + ' ' +\
7556            'tls_required: ' + repr(self.tls_required) + ' ' +\
7557            'username: ' + repr(self.username) + ' ' +\
7558            '>'
7559
7560    def to_dict(self):
7561        return {
7562            'auth_database': self.auth_database,
7563            'connect_to_replica': self.connect_to_replica,
7564            'egress_filter': self.egress_filter,
7565            'healthy': self.healthy,
7566            'hostname': self.hostname,
7567            'id': self.id,
7568            'name': self.name,
7569            'password': self.password,
7570            'port': self.port,
7571            'port_override': self.port_override,
7572            'replica_set': self.replica_set,
7573            'secret_store_id': self.secret_store_id,
7574            'tags': self.tags,
7575            'tls_required': self.tls_required,
7576            'username': self.username,
7577        }
7578
7579    @classmethod
7580    def from_dict(cls, d):
7581        return cls(
7582            auth_database=d.get('auth_database'),
7583            connect_to_replica=d.get('connect_to_replica'),
7584            egress_filter=d.get('egress_filter'),
7585            healthy=d.get('healthy'),
7586            hostname=d.get('hostname'),
7587            id=d.get('id'),
7588            name=d.get('name'),
7589            password=d.get('password'),
7590            port=d.get('port'),
7591            port_override=d.get('port_override'),
7592            replica_set=d.get('replica_set'),
7593            secret_store_id=d.get('secret_store_id'),
7594            tags=d.get('tags'),
7595            tls_required=d.get('tls_required'),
7596            username=d.get('username'),
7597        )
#   MongoLegacyReplicaset( auth_database=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
7462    def __init__(
7463        self,
7464        auth_database=None,
7465        connect_to_replica=None,
7466        egress_filter=None,
7467        healthy=None,
7468        hostname=None,
7469        id=None,
7470        name=None,
7471        password=None,
7472        port=None,
7473        port_override=None,
7474        replica_set=None,
7475        secret_store_id=None,
7476        tags=None,
7477        tls_required=None,
7478        username=None,
7479    ):
7480        self.auth_database = auth_database if auth_database is not None else ''
7481        '''
7482
7483        '''
7484        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7485        '''
7486
7487        '''
7488        self.egress_filter = egress_filter if egress_filter is not None else ''
7489        '''
7490         A filter applied to the routing logic to pin datasource to nodes.
7491        '''
7492        self.healthy = healthy if healthy is not None else False
7493        '''
7494         True if the datasource is reachable and the credentials are valid.
7495        '''
7496        self.hostname = hostname if hostname is not None else ''
7497        '''
7498
7499        '''
7500        self.id = id if id is not None else ''
7501        '''
7502         Unique identifier of the Resource.
7503        '''
7504        self.name = name if name is not None else ''
7505        '''
7506         Unique human-readable name of the Resource.
7507        '''
7508        self.password = password if password is not None else ''
7509        '''
7510
7511        '''
7512        self.port = port if port is not None else 0
7513        '''
7514
7515        '''
7516        self.port_override = port_override if port_override is not None else 0
7517        '''
7518
7519        '''
7520        self.replica_set = replica_set if replica_set is not None else ''
7521        '''
7522
7523        '''
7524        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7525        '''
7526         ID of the secret store containing credentials for this resource, if any.
7527        '''
7528        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7529        '''
7530         Tags is a map of key, value pairs.
7531        '''
7532        self.tls_required = tls_required if tls_required is not None else False
7533        '''
7534
7535        '''
7536        self.username = username if username is not None else ''
7537        '''
7538
7539        '''
#   auth_database
#   connect_to_replica
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   replica_set
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
7560    def to_dict(self):
7561        return {
7562            'auth_database': self.auth_database,
7563            'connect_to_replica': self.connect_to_replica,
7564            'egress_filter': self.egress_filter,
7565            'healthy': self.healthy,
7566            'hostname': self.hostname,
7567            'id': self.id,
7568            'name': self.name,
7569            'password': self.password,
7570            'port': self.port,
7571            'port_override': self.port_override,
7572            'replica_set': self.replica_set,
7573            'secret_store_id': self.secret_store_id,
7574            'tags': self.tags,
7575            'tls_required': self.tls_required,
7576            'username': self.username,
7577        }
#  
@classmethod
def from_dict(cls, d):
View Source
7579    @classmethod
7580    def from_dict(cls, d):
7581        return cls(
7582            auth_database=d.get('auth_database'),
7583            connect_to_replica=d.get('connect_to_replica'),
7584            egress_filter=d.get('egress_filter'),
7585            healthy=d.get('healthy'),
7586            hostname=d.get('hostname'),
7587            id=d.get('id'),
7588            name=d.get('name'),
7589            password=d.get('password'),
7590            port=d.get('port'),
7591            port_override=d.get('port_override'),
7592            replica_set=d.get('replica_set'),
7593            secret_store_id=d.get('secret_store_id'),
7594            tags=d.get('tags'),
7595            tls_required=d.get('tls_required'),
7596            username=d.get('username'),
7597        )
#   class MongoReplicaSet:
View Source
7600class MongoReplicaSet:
7601    '''
7602
7603    '''
7604    __slots__ = [
7605        'auth_database',
7606        'connect_to_replica',
7607        'egress_filter',
7608        'healthy',
7609        'hostname',
7610        'id',
7611        'name',
7612        'password',
7613        'port',
7614        'port_override',
7615        'replica_set',
7616        'secret_store_id',
7617        'tags',
7618        'tls_required',
7619        'username',
7620    ]
7621
7622    def __init__(
7623        self,
7624        auth_database=None,
7625        connect_to_replica=None,
7626        egress_filter=None,
7627        healthy=None,
7628        hostname=None,
7629        id=None,
7630        name=None,
7631        password=None,
7632        port=None,
7633        port_override=None,
7634        replica_set=None,
7635        secret_store_id=None,
7636        tags=None,
7637        tls_required=None,
7638        username=None,
7639    ):
7640        self.auth_database = auth_database if auth_database is not None else ''
7641        '''
7642
7643        '''
7644        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7645        '''
7646
7647        '''
7648        self.egress_filter = egress_filter if egress_filter is not None else ''
7649        '''
7650         A filter applied to the routing logic to pin datasource to nodes.
7651        '''
7652        self.healthy = healthy if healthy is not None else False
7653        '''
7654         True if the datasource is reachable and the credentials are valid.
7655        '''
7656        self.hostname = hostname if hostname is not None else ''
7657        '''
7658
7659        '''
7660        self.id = id if id is not None else ''
7661        '''
7662         Unique identifier of the Resource.
7663        '''
7664        self.name = name if name is not None else ''
7665        '''
7666         Unique human-readable name of the Resource.
7667        '''
7668        self.password = password if password is not None else ''
7669        '''
7670
7671        '''
7672        self.port = port if port is not None else 0
7673        '''
7674
7675        '''
7676        self.port_override = port_override if port_override is not None else 0
7677        '''
7678
7679        '''
7680        self.replica_set = replica_set if replica_set is not None else ''
7681        '''
7682
7683        '''
7684        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7685        '''
7686         ID of the secret store containing credentials for this resource, if any.
7687        '''
7688        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7689        '''
7690         Tags is a map of key, value pairs.
7691        '''
7692        self.tls_required = tls_required if tls_required is not None else False
7693        '''
7694
7695        '''
7696        self.username = username if username is not None else ''
7697        '''
7698
7699        '''
7700
7701    def __repr__(self):
7702        return '<sdm.MongoReplicaSet ' + \
7703            'auth_database: ' + repr(self.auth_database) + ' ' +\
7704            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7705            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7706            'healthy: ' + repr(self.healthy) + ' ' +\
7707            'hostname: ' + repr(self.hostname) + ' ' +\
7708            'id: ' + repr(self.id) + ' ' +\
7709            'name: ' + repr(self.name) + ' ' +\
7710            'password: ' + repr(self.password) + ' ' +\
7711            'port: ' + repr(self.port) + ' ' +\
7712            'port_override: ' + repr(self.port_override) + ' ' +\
7713            'replica_set: ' + repr(self.replica_set) + ' ' +\
7714            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7715            'tags: ' + repr(self.tags) + ' ' +\
7716            'tls_required: ' + repr(self.tls_required) + ' ' +\
7717            'username: ' + repr(self.username) + ' ' +\
7718            '>'
7719
7720    def to_dict(self):
7721        return {
7722            'auth_database': self.auth_database,
7723            'connect_to_replica': self.connect_to_replica,
7724            'egress_filter': self.egress_filter,
7725            'healthy': self.healthy,
7726            'hostname': self.hostname,
7727            'id': self.id,
7728            'name': self.name,
7729            'password': self.password,
7730            'port': self.port,
7731            'port_override': self.port_override,
7732            'replica_set': self.replica_set,
7733            'secret_store_id': self.secret_store_id,
7734            'tags': self.tags,
7735            'tls_required': self.tls_required,
7736            'username': self.username,
7737        }
7738
7739    @classmethod
7740    def from_dict(cls, d):
7741        return cls(
7742            auth_database=d.get('auth_database'),
7743            connect_to_replica=d.get('connect_to_replica'),
7744            egress_filter=d.get('egress_filter'),
7745            healthy=d.get('healthy'),
7746            hostname=d.get('hostname'),
7747            id=d.get('id'),
7748            name=d.get('name'),
7749            password=d.get('password'),
7750            port=d.get('port'),
7751            port_override=d.get('port_override'),
7752            replica_set=d.get('replica_set'),
7753            secret_store_id=d.get('secret_store_id'),
7754            tags=d.get('tags'),
7755            tls_required=d.get('tls_required'),
7756            username=d.get('username'),
7757        )
#   MongoReplicaSet( auth_database=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
7622    def __init__(
7623        self,
7624        auth_database=None,
7625        connect_to_replica=None,
7626        egress_filter=None,
7627        healthy=None,
7628        hostname=None,
7629        id=None,
7630        name=None,
7631        password=None,
7632        port=None,
7633        port_override=None,
7634        replica_set=None,
7635        secret_store_id=None,
7636        tags=None,
7637        tls_required=None,
7638        username=None,
7639    ):
7640        self.auth_database = auth_database if auth_database is not None else ''
7641        '''
7642
7643        '''
7644        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7645        '''
7646
7647        '''
7648        self.egress_filter = egress_filter if egress_filter is not None else ''
7649        '''
7650         A filter applied to the routing logic to pin datasource to nodes.
7651        '''
7652        self.healthy = healthy if healthy is not None else False
7653        '''
7654         True if the datasource is reachable and the credentials are valid.
7655        '''
7656        self.hostname = hostname if hostname is not None else ''
7657        '''
7658
7659        '''
7660        self.id = id if id is not None else ''
7661        '''
7662         Unique identifier of the Resource.
7663        '''
7664        self.name = name if name is not None else ''
7665        '''
7666         Unique human-readable name of the Resource.
7667        '''
7668        self.password = password if password is not None else ''
7669        '''
7670
7671        '''
7672        self.port = port if port is not None else 0
7673        '''
7674
7675        '''
7676        self.port_override = port_override if port_override is not None else 0
7677        '''
7678
7679        '''
7680        self.replica_set = replica_set if replica_set is not None else ''
7681        '''
7682
7683        '''
7684        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7685        '''
7686         ID of the secret store containing credentials for this resource, if any.
7687        '''
7688        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7689        '''
7690         Tags is a map of key, value pairs.
7691        '''
7692        self.tls_required = tls_required if tls_required is not None else False
7693        '''
7694
7695        '''
7696        self.username = username if username is not None else ''
7697        '''
7698
7699        '''
#   auth_database
#   connect_to_replica
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   replica_set
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
7720    def to_dict(self):
7721        return {
7722            'auth_database': self.auth_database,
7723            'connect_to_replica': self.connect_to_replica,
7724            'egress_filter': self.egress_filter,
7725            'healthy': self.healthy,
7726            'hostname': self.hostname,
7727            'id': self.id,
7728            'name': self.name,
7729            'password': self.password,
7730            'port': self.port,
7731            'port_override': self.port_override,
7732            'replica_set': self.replica_set,
7733            'secret_store_id': self.secret_store_id,
7734            'tags': self.tags,
7735            'tls_required': self.tls_required,
7736            'username': self.username,
7737        }
#  
@classmethod
def from_dict(cls, d):
View Source
7739    @classmethod
7740    def from_dict(cls, d):
7741        return cls(
7742            auth_database=d.get('auth_database'),
7743            connect_to_replica=d.get('connect_to_replica'),
7744            egress_filter=d.get('egress_filter'),
7745            healthy=d.get('healthy'),
7746            hostname=d.get('hostname'),
7747            id=d.get('id'),
7748            name=d.get('name'),
7749            password=d.get('password'),
7750            port=d.get('port'),
7751            port_override=d.get('port_override'),
7752            replica_set=d.get('replica_set'),
7753            secret_store_id=d.get('secret_store_id'),
7754            tags=d.get('tags'),
7755            tls_required=d.get('tls_required'),
7756            username=d.get('username'),
7757        )
#   class MongoShardedCluster:
View Source
7760class MongoShardedCluster:
7761    '''
7762
7763    '''
7764    __slots__ = [
7765        'auth_database',
7766        'egress_filter',
7767        'healthy',
7768        'hostname',
7769        'id',
7770        'name',
7771        'password',
7772        'port_override',
7773        'secret_store_id',
7774        'tags',
7775        'tls_required',
7776        'username',
7777    ]
7778
7779    def __init__(
7780        self,
7781        auth_database=None,
7782        egress_filter=None,
7783        healthy=None,
7784        hostname=None,
7785        id=None,
7786        name=None,
7787        password=None,
7788        port_override=None,
7789        secret_store_id=None,
7790        tags=None,
7791        tls_required=None,
7792        username=None,
7793    ):
7794        self.auth_database = auth_database if auth_database is not None else ''
7795        '''
7796
7797        '''
7798        self.egress_filter = egress_filter if egress_filter is not None else ''
7799        '''
7800         A filter applied to the routing logic to pin datasource to nodes.
7801        '''
7802        self.healthy = healthy if healthy is not None else False
7803        '''
7804         True if the datasource is reachable and the credentials are valid.
7805        '''
7806        self.hostname = hostname if hostname is not None else ''
7807        '''
7808
7809        '''
7810        self.id = id if id is not None else ''
7811        '''
7812         Unique identifier of the Resource.
7813        '''
7814        self.name = name if name is not None else ''
7815        '''
7816         Unique human-readable name of the Resource.
7817        '''
7818        self.password = password if password is not None else ''
7819        '''
7820
7821        '''
7822        self.port_override = port_override if port_override is not None else 0
7823        '''
7824
7825        '''
7826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7827        '''
7828         ID of the secret store containing credentials for this resource, if any.
7829        '''
7830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7831        '''
7832         Tags is a map of key, value pairs.
7833        '''
7834        self.tls_required = tls_required if tls_required is not None else False
7835        '''
7836
7837        '''
7838        self.username = username if username is not None else ''
7839        '''
7840
7841        '''
7842
7843    def __repr__(self):
7844        return '<sdm.MongoShardedCluster ' + \
7845            'auth_database: ' + repr(self.auth_database) + ' ' +\
7846            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7847            'healthy: ' + repr(self.healthy) + ' ' +\
7848            'hostname: ' + repr(self.hostname) + ' ' +\
7849            'id: ' + repr(self.id) + ' ' +\
7850            'name: ' + repr(self.name) + ' ' +\
7851            'password: ' + repr(self.password) + ' ' +\
7852            'port_override: ' + repr(self.port_override) + ' ' +\
7853            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7854            'tags: ' + repr(self.tags) + ' ' +\
7855            'tls_required: ' + repr(self.tls_required) + ' ' +\
7856            'username: ' + repr(self.username) + ' ' +\
7857            '>'
7858
7859    def to_dict(self):
7860        return {
7861            'auth_database': self.auth_database,
7862            'egress_filter': self.egress_filter,
7863            'healthy': self.healthy,
7864            'hostname': self.hostname,
7865            'id': self.id,
7866            'name': self.name,
7867            'password': self.password,
7868            'port_override': self.port_override,
7869            'secret_store_id': self.secret_store_id,
7870            'tags': self.tags,
7871            'tls_required': self.tls_required,
7872            'username': self.username,
7873        }
7874
7875    @classmethod
7876    def from_dict(cls, d):
7877        return cls(
7878            auth_database=d.get('auth_database'),
7879            egress_filter=d.get('egress_filter'),
7880            healthy=d.get('healthy'),
7881            hostname=d.get('hostname'),
7882            id=d.get('id'),
7883            name=d.get('name'),
7884            password=d.get('password'),
7885            port_override=d.get('port_override'),
7886            secret_store_id=d.get('secret_store_id'),
7887            tags=d.get('tags'),
7888            tls_required=d.get('tls_required'),
7889            username=d.get('username'),
7890        )
#   MongoShardedCluster( auth_database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
7779    def __init__(
7780        self,
7781        auth_database=None,
7782        egress_filter=None,
7783        healthy=None,
7784        hostname=None,
7785        id=None,
7786        name=None,
7787        password=None,
7788        port_override=None,
7789        secret_store_id=None,
7790        tags=None,
7791        tls_required=None,
7792        username=None,
7793    ):
7794        self.auth_database = auth_database if auth_database is not None else ''
7795        '''
7796
7797        '''
7798        self.egress_filter = egress_filter if egress_filter is not None else ''
7799        '''
7800         A filter applied to the routing logic to pin datasource to nodes.
7801        '''
7802        self.healthy = healthy if healthy is not None else False
7803        '''
7804         True if the datasource is reachable and the credentials are valid.
7805        '''
7806        self.hostname = hostname if hostname is not None else ''
7807        '''
7808
7809        '''
7810        self.id = id if id is not None else ''
7811        '''
7812         Unique identifier of the Resource.
7813        '''
7814        self.name = name if name is not None else ''
7815        '''
7816         Unique human-readable name of the Resource.
7817        '''
7818        self.password = password if password is not None else ''
7819        '''
7820
7821        '''
7822        self.port_override = port_override if port_override is not None else 0
7823        '''
7824
7825        '''
7826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7827        '''
7828         ID of the secret store containing credentials for this resource, if any.
7829        '''
7830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7831        '''
7832         Tags is a map of key, value pairs.
7833        '''
7834        self.tls_required = tls_required if tls_required is not None else False
7835        '''
7836
7837        '''
7838        self.username = username if username is not None else ''
7839        '''
7840
7841        '''
#   auth_database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
7859    def to_dict(self):
7860        return {
7861            'auth_database': self.auth_database,
7862            'egress_filter': self.egress_filter,
7863            'healthy': self.healthy,
7864            'hostname': self.hostname,
7865            'id': self.id,
7866            'name': self.name,
7867            'password': self.password,
7868            'port_override': self.port_override,
7869            'secret_store_id': self.secret_store_id,
7870            'tags': self.tags,
7871            'tls_required': self.tls_required,
7872            'username': self.username,
7873        }
#  
@classmethod
def from_dict(cls, d):
View Source
7875    @classmethod
7876    def from_dict(cls, d):
7877        return cls(
7878            auth_database=d.get('auth_database'),
7879            egress_filter=d.get('egress_filter'),
7880            healthy=d.get('healthy'),
7881            hostname=d.get('hostname'),
7882            id=d.get('id'),
7883            name=d.get('name'),
7884            password=d.get('password'),
7885            port_override=d.get('port_override'),
7886            secret_store_id=d.get('secret_store_id'),
7887            tags=d.get('tags'),
7888            tls_required=d.get('tls_required'),
7889            username=d.get('username'),
7890        )
#   class Mysql:
View Source
7893class Mysql:
7894    '''
7895
7896    '''
7897    __slots__ = [
7898        'database',
7899        'egress_filter',
7900        'healthy',
7901        'hostname',
7902        'id',
7903        'name',
7904        'password',
7905        'port',
7906        'port_override',
7907        'secret_store_id',
7908        'tags',
7909        'username',
7910    ]
7911
7912    def __init__(
7913        self,
7914        database=None,
7915        egress_filter=None,
7916        healthy=None,
7917        hostname=None,
7918        id=None,
7919        name=None,
7920        password=None,
7921        port=None,
7922        port_override=None,
7923        secret_store_id=None,
7924        tags=None,
7925        username=None,
7926    ):
7927        self.database = database if database is not None else ''
7928        '''
7929
7930        '''
7931        self.egress_filter = egress_filter if egress_filter is not None else ''
7932        '''
7933         A filter applied to the routing logic to pin datasource to nodes.
7934        '''
7935        self.healthy = healthy if healthy is not None else False
7936        '''
7937         True if the datasource is reachable and the credentials are valid.
7938        '''
7939        self.hostname = hostname if hostname is not None else ''
7940        '''
7941
7942        '''
7943        self.id = id if id is not None else ''
7944        '''
7945         Unique identifier of the Resource.
7946        '''
7947        self.name = name if name is not None else ''
7948        '''
7949         Unique human-readable name of the Resource.
7950        '''
7951        self.password = password if password is not None else ''
7952        '''
7953
7954        '''
7955        self.port = port if port is not None else 0
7956        '''
7957
7958        '''
7959        self.port_override = port_override if port_override is not None else 0
7960        '''
7961
7962        '''
7963        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7964        '''
7965         ID of the secret store containing credentials for this resource, if any.
7966        '''
7967        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7968        '''
7969         Tags is a map of key, value pairs.
7970        '''
7971        self.username = username if username is not None else ''
7972        '''
7973
7974        '''
7975
7976    def __repr__(self):
7977        return '<sdm.Mysql ' + \
7978            'database: ' + repr(self.database) + ' ' +\
7979            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7980            'healthy: ' + repr(self.healthy) + ' ' +\
7981            'hostname: ' + repr(self.hostname) + ' ' +\
7982            'id: ' + repr(self.id) + ' ' +\
7983            'name: ' + repr(self.name) + ' ' +\
7984            'password: ' + repr(self.password) + ' ' +\
7985            'port: ' + repr(self.port) + ' ' +\
7986            'port_override: ' + repr(self.port_override) + ' ' +\
7987            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7988            'tags: ' + repr(self.tags) + ' ' +\
7989            'username: ' + repr(self.username) + ' ' +\
7990            '>'
7991
7992    def to_dict(self):
7993        return {
7994            'database': self.database,
7995            'egress_filter': self.egress_filter,
7996            'healthy': self.healthy,
7997            'hostname': self.hostname,
7998            'id': self.id,
7999            'name': self.name,
8000            'password': self.password,
8001            'port': self.port,
8002            'port_override': self.port_override,
8003            'secret_store_id': self.secret_store_id,
8004            'tags': self.tags,
8005            'username': self.username,
8006        }
8007
8008    @classmethod
8009    def from_dict(cls, d):
8010        return cls(
8011            database=d.get('database'),
8012            egress_filter=d.get('egress_filter'),
8013            healthy=d.get('healthy'),
8014            hostname=d.get('hostname'),
8015            id=d.get('id'),
8016            name=d.get('name'),
8017            password=d.get('password'),
8018            port=d.get('port'),
8019            port_override=d.get('port_override'),
8020            secret_store_id=d.get('secret_store_id'),
8021            tags=d.get('tags'),
8022            username=d.get('username'),
8023        )
#   Mysql( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
7912    def __init__(
7913        self,
7914        database=None,
7915        egress_filter=None,
7916        healthy=None,
7917        hostname=None,
7918        id=None,
7919        name=None,
7920        password=None,
7921        port=None,
7922        port_override=None,
7923        secret_store_id=None,
7924        tags=None,
7925        username=None,
7926    ):
7927        self.database = database if database is not None else ''
7928        '''
7929
7930        '''
7931        self.egress_filter = egress_filter if egress_filter is not None else ''
7932        '''
7933         A filter applied to the routing logic to pin datasource to nodes.
7934        '''
7935        self.healthy = healthy if healthy is not None else False
7936        '''
7937         True if the datasource is reachable and the credentials are valid.
7938        '''
7939        self.hostname = hostname if hostname is not None else ''
7940        '''
7941
7942        '''
7943        self.id = id if id is not None else ''
7944        '''
7945         Unique identifier of the Resource.
7946        '''
7947        self.name = name if name is not None else ''
7948        '''
7949         Unique human-readable name of the Resource.
7950        '''
7951        self.password = password if password is not None else ''
7952        '''
7953
7954        '''
7955        self.port = port if port is not None else 0
7956        '''
7957
7958        '''
7959        self.port_override = port_override if port_override is not None else 0
7960        '''
7961
7962        '''
7963        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7964        '''
7965         ID of the secret store containing credentials for this resource, if any.
7966        '''
7967        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7968        '''
7969         Tags is a map of key, value pairs.
7970        '''
7971        self.username = username if username is not None else ''
7972        '''
7973
7974        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
7992    def to_dict(self):
7993        return {
7994            'database': self.database,
7995            'egress_filter': self.egress_filter,
7996            'healthy': self.healthy,
7997            'hostname': self.hostname,
7998            'id': self.id,
7999            'name': self.name,
8000            'password': self.password,
8001            'port': self.port,
8002            'port_override': self.port_override,
8003            'secret_store_id': self.secret_store_id,
8004            'tags': self.tags,
8005            'username': self.username,
8006        }
#  
@classmethod
def from_dict(cls, d):
View Source
8008    @classmethod
8009    def from_dict(cls, d):
8010        return cls(
8011            database=d.get('database'),
8012            egress_filter=d.get('egress_filter'),
8013            healthy=d.get('healthy'),
8014            hostname=d.get('hostname'),
8015            id=d.get('id'),
8016            name=d.get('name'),
8017            password=d.get('password'),
8018            port=d.get('port'),
8019            port_override=d.get('port_override'),
8020            secret_store_id=d.get('secret_store_id'),
8021            tags=d.get('tags'),
8022            username=d.get('username'),
8023        )
#   class Neptune:
View Source
8026class Neptune:
8027    '''
8028
8029    '''
8030    __slots__ = [
8031        'egress_filter',
8032        'endpoint',
8033        'healthy',
8034        'id',
8035        'name',
8036        'port',
8037        'port_override',
8038        'secret_store_id',
8039        'tags',
8040    ]
8041
8042    def __init__(
8043        self,
8044        egress_filter=None,
8045        endpoint=None,
8046        healthy=None,
8047        id=None,
8048        name=None,
8049        port=None,
8050        port_override=None,
8051        secret_store_id=None,
8052        tags=None,
8053    ):
8054        self.egress_filter = egress_filter if egress_filter is not None else ''
8055        '''
8056         A filter applied to the routing logic to pin datasource to nodes.
8057        '''
8058        self.endpoint = endpoint if endpoint is not None else ''
8059        '''
8060
8061        '''
8062        self.healthy = healthy if healthy is not None else False
8063        '''
8064         True if the datasource is reachable and the credentials are valid.
8065        '''
8066        self.id = id if id is not None else ''
8067        '''
8068         Unique identifier of the Resource.
8069        '''
8070        self.name = name if name is not None else ''
8071        '''
8072         Unique human-readable name of the Resource.
8073        '''
8074        self.port = port if port is not None else 0
8075        '''
8076
8077        '''
8078        self.port_override = port_override if port_override is not None else 0
8079        '''
8080
8081        '''
8082        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8083        '''
8084         ID of the secret store containing credentials for this resource, if any.
8085        '''
8086        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8087        '''
8088         Tags is a map of key, value pairs.
8089        '''
8090
8091    def __repr__(self):
8092        return '<sdm.Neptune ' + \
8093            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8094            'endpoint: ' + repr(self.endpoint) + ' ' +\
8095            'healthy: ' + repr(self.healthy) + ' ' +\
8096            'id: ' + repr(self.id) + ' ' +\
8097            'name: ' + repr(self.name) + ' ' +\
8098            'port: ' + repr(self.port) + ' ' +\
8099            'port_override: ' + repr(self.port_override) + ' ' +\
8100            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8101            'tags: ' + repr(self.tags) + ' ' +\
8102            '>'
8103
8104    def to_dict(self):
8105        return {
8106            'egress_filter': self.egress_filter,
8107            'endpoint': self.endpoint,
8108            'healthy': self.healthy,
8109            'id': self.id,
8110            'name': self.name,
8111            'port': self.port,
8112            'port_override': self.port_override,
8113            'secret_store_id': self.secret_store_id,
8114            'tags': self.tags,
8115        }
8116
8117    @classmethod
8118    def from_dict(cls, d):
8119        return cls(
8120            egress_filter=d.get('egress_filter'),
8121            endpoint=d.get('endpoint'),
8122            healthy=d.get('healthy'),
8123            id=d.get('id'),
8124            name=d.get('name'),
8125            port=d.get('port'),
8126            port_override=d.get('port_override'),
8127            secret_store_id=d.get('secret_store_id'),
8128            tags=d.get('tags'),
8129        )
#   Neptune( egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
8042    def __init__(
8043        self,
8044        egress_filter=None,
8045        endpoint=None,
8046        healthy=None,
8047        id=None,
8048        name=None,
8049        port=None,
8050        port_override=None,
8051        secret_store_id=None,
8052        tags=None,
8053    ):
8054        self.egress_filter = egress_filter if egress_filter is not None else ''
8055        '''
8056         A filter applied to the routing logic to pin datasource to nodes.
8057        '''
8058        self.endpoint = endpoint if endpoint is not None else ''
8059        '''
8060
8061        '''
8062        self.healthy = healthy if healthy is not None else False
8063        '''
8064         True if the datasource is reachable and the credentials are valid.
8065        '''
8066        self.id = id if id is not None else ''
8067        '''
8068         Unique identifier of the Resource.
8069        '''
8070        self.name = name if name is not None else ''
8071        '''
8072         Unique human-readable name of the Resource.
8073        '''
8074        self.port = port if port is not None else 0
8075        '''
8076
8077        '''
8078        self.port_override = port_override if port_override is not None else 0
8079        '''
8080
8081        '''
8082        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8083        '''
8084         ID of the secret store containing credentials for this resource, if any.
8085        '''
8086        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8087        '''
8088         Tags is a map of key, value pairs.
8089        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
8104    def to_dict(self):
8105        return {
8106            'egress_filter': self.egress_filter,
8107            'endpoint': self.endpoint,
8108            'healthy': self.healthy,
8109            'id': self.id,
8110            'name': self.name,
8111            'port': self.port,
8112            'port_override': self.port_override,
8113            'secret_store_id': self.secret_store_id,
8114            'tags': self.tags,
8115        }
#  
@classmethod
def from_dict(cls, d):
View Source
8117    @classmethod
8118    def from_dict(cls, d):
8119        return cls(
8120            egress_filter=d.get('egress_filter'),
8121            endpoint=d.get('endpoint'),
8122            healthy=d.get('healthy'),
8123            id=d.get('id'),
8124            name=d.get('name'),
8125            port=d.get('port'),
8126            port_override=d.get('port_override'),
8127            secret_store_id=d.get('secret_store_id'),
8128            tags=d.get('tags'),
8129        )
#   class NeptuneIAM:
View Source
8132class NeptuneIAM:
8133    '''
8134
8135    '''
8136    __slots__ = [
8137        'access_key',
8138        'egress_filter',
8139        'endpoint',
8140        'healthy',
8141        'id',
8142        'name',
8143        'port',
8144        'port_override',
8145        'region',
8146        'role_arn',
8147        'role_external_id',
8148        'secret_access_key',
8149        'secret_store_id',
8150        'tags',
8151    ]
8152
8153    def __init__(
8154        self,
8155        access_key=None,
8156        egress_filter=None,
8157        endpoint=None,
8158        healthy=None,
8159        id=None,
8160        name=None,
8161        port=None,
8162        port_override=None,
8163        region=None,
8164        role_arn=None,
8165        role_external_id=None,
8166        secret_access_key=None,
8167        secret_store_id=None,
8168        tags=None,
8169    ):
8170        self.access_key = access_key if access_key is not None else ''
8171        '''
8172
8173        '''
8174        self.egress_filter = egress_filter if egress_filter is not None else ''
8175        '''
8176         A filter applied to the routing logic to pin datasource to nodes.
8177        '''
8178        self.endpoint = endpoint if endpoint is not None else ''
8179        '''
8180
8181        '''
8182        self.healthy = healthy if healthy is not None else False
8183        '''
8184         True if the datasource is reachable and the credentials are valid.
8185        '''
8186        self.id = id if id is not None else ''
8187        '''
8188         Unique identifier of the Resource.
8189        '''
8190        self.name = name if name is not None else ''
8191        '''
8192         Unique human-readable name of the Resource.
8193        '''
8194        self.port = port if port is not None else 0
8195        '''
8196
8197        '''
8198        self.port_override = port_override if port_override is not None else 0
8199        '''
8200
8201        '''
8202        self.region = region if region is not None else ''
8203        '''
8204
8205        '''
8206        self.role_arn = role_arn if role_arn is not None else ''
8207        '''
8208
8209        '''
8210        self.role_external_id = role_external_id if role_external_id is not None else ''
8211        '''
8212
8213        '''
8214        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8215        '''
8216
8217        '''
8218        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8219        '''
8220         ID of the secret store containing credentials for this resource, if any.
8221        '''
8222        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8223        '''
8224         Tags is a map of key, value pairs.
8225        '''
8226
8227    def __repr__(self):
8228        return '<sdm.NeptuneIAM ' + \
8229            'access_key: ' + repr(self.access_key) + ' ' +\
8230            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8231            'endpoint: ' + repr(self.endpoint) + ' ' +\
8232            'healthy: ' + repr(self.healthy) + ' ' +\
8233            'id: ' + repr(self.id) + ' ' +\
8234            'name: ' + repr(self.name) + ' ' +\
8235            'port: ' + repr(self.port) + ' ' +\
8236            'port_override: ' + repr(self.port_override) + ' ' +\
8237            'region: ' + repr(self.region) + ' ' +\
8238            'role_arn: ' + repr(self.role_arn) + ' ' +\
8239            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8240            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8241            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8242            'tags: ' + repr(self.tags) + ' ' +\
8243            '>'
8244
8245    def to_dict(self):
8246        return {
8247            'access_key': self.access_key,
8248            'egress_filter': self.egress_filter,
8249            'endpoint': self.endpoint,
8250            'healthy': self.healthy,
8251            'id': self.id,
8252            'name': self.name,
8253            'port': self.port,
8254            'port_override': self.port_override,
8255            'region': self.region,
8256            'role_arn': self.role_arn,
8257            'role_external_id': self.role_external_id,
8258            'secret_access_key': self.secret_access_key,
8259            'secret_store_id': self.secret_store_id,
8260            'tags': self.tags,
8261        }
8262
8263    @classmethod
8264    def from_dict(cls, d):
8265        return cls(
8266            access_key=d.get('access_key'),
8267            egress_filter=d.get('egress_filter'),
8268            endpoint=d.get('endpoint'),
8269            healthy=d.get('healthy'),
8270            id=d.get('id'),
8271            name=d.get('name'),
8272            port=d.get('port'),
8273            port_override=d.get('port_override'),
8274            region=d.get('region'),
8275            role_arn=d.get('role_arn'),
8276            role_external_id=d.get('role_external_id'),
8277            secret_access_key=d.get('secret_access_key'),
8278            secret_store_id=d.get('secret_store_id'),
8279            tags=d.get('tags'),
8280        )
#   NeptuneIAM( access_key=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None )
View Source
8153    def __init__(
8154        self,
8155        access_key=None,
8156        egress_filter=None,
8157        endpoint=None,
8158        healthy=None,
8159        id=None,
8160        name=None,
8161        port=None,
8162        port_override=None,
8163        region=None,
8164        role_arn=None,
8165        role_external_id=None,
8166        secret_access_key=None,
8167        secret_store_id=None,
8168        tags=None,
8169    ):
8170        self.access_key = access_key if access_key is not None else ''
8171        '''
8172
8173        '''
8174        self.egress_filter = egress_filter if egress_filter is not None else ''
8175        '''
8176         A filter applied to the routing logic to pin datasource to nodes.
8177        '''
8178        self.endpoint = endpoint if endpoint is not None else ''
8179        '''
8180
8181        '''
8182        self.healthy = healthy if healthy is not None else False
8183        '''
8184         True if the datasource is reachable and the credentials are valid.
8185        '''
8186        self.id = id if id is not None else ''
8187        '''
8188         Unique identifier of the Resource.
8189        '''
8190        self.name = name if name is not None else ''
8191        '''
8192         Unique human-readable name of the Resource.
8193        '''
8194        self.port = port if port is not None else 0
8195        '''
8196
8197        '''
8198        self.port_override = port_override if port_override is not None else 0
8199        '''
8200
8201        '''
8202        self.region = region if region is not None else ''
8203        '''
8204
8205        '''
8206        self.role_arn = role_arn if role_arn is not None else ''
8207        '''
8208
8209        '''
8210        self.role_external_id = role_external_id if role_external_id is not None else ''
8211        '''
8212
8213        '''
8214        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8215        '''
8216
8217        '''
8218        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8219        '''
8220         ID of the secret store containing credentials for this resource, if any.
8221        '''
8222        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8223        '''
8224         Tags is a map of key, value pairs.
8225        '''
#   access_key
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   endpoint
#   healthy

True if the datasource is reachable and the credentials are valid.

#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_override
#   region
#   role_arn
#   role_external_id
#   secret_access_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
8245    def to_dict(self):
8246        return {
8247            'access_key': self.access_key,
8248            'egress_filter': self.egress_filter,
8249            'endpoint': self.endpoint,
8250            'healthy': self.healthy,
8251            'id': self.id,
8252            'name': self.name,
8253            'port': self.port,
8254            'port_override': self.port_override,
8255            'region': self.region,
8256            'role_arn': self.role_arn,
8257            'role_external_id': self.role_external_id,
8258            'secret_access_key': self.secret_access_key,
8259            'secret_store_id': self.secret_store_id,
8260            'tags': self.tags,
8261        }
#  
@classmethod
def from_dict(cls, d):
View Source
8263    @classmethod
8264    def from_dict(cls, d):
8265        return cls(
8266            access_key=d.get('access_key'),
8267            egress_filter=d.get('egress_filter'),
8268            endpoint=d.get('endpoint'),
8269            healthy=d.get('healthy'),
8270            id=d.get('id'),
8271            name=d.get('name'),
8272            port=d.get('port'),
8273            port_override=d.get('port_override'),
8274            region=d.get('region'),
8275            role_arn=d.get('role_arn'),
8276            role_external_id=d.get('role_external_id'),
8277            secret_access_key=d.get('secret_access_key'),
8278            secret_store_id=d.get('secret_store_id'),
8279            tags=d.get('tags'),
8280        )
#   class NodeCreateResponse:
View Source
8283class NodeCreateResponse:
8284    '''
8285     NodeCreateResponse reports how the Nodes were created in the system.
8286    '''
8287    __slots__ = [
8288        'meta',
8289        'node',
8290        'rate_limit',
8291        'token',
8292    ]
8293
8294    def __init__(
8295        self,
8296        meta=None,
8297        node=None,
8298        rate_limit=None,
8299        token=None,
8300    ):
8301        self.meta = meta if meta is not None else None
8302        '''
8303         Reserved for future use.
8304        '''
8305        self.node = node if node is not None else None
8306        '''
8307         The created Node.
8308        '''
8309        self.rate_limit = rate_limit if rate_limit is not None else None
8310        '''
8311         Rate limit information.
8312        '''
8313        self.token = token if token is not None else ''
8314        '''
8315         The auth token generated for the Node. The Node will use this token to
8316         authenticate with the strongDM API.
8317        '''
8318
8319    def __repr__(self):
8320        return '<sdm.NodeCreateResponse ' + \
8321            'meta: ' + repr(self.meta) + ' ' +\
8322            'node: ' + repr(self.node) + ' ' +\
8323            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8324            'token: ' + repr(self.token) + ' ' +\
8325            '>'
8326
8327    def to_dict(self):
8328        return {
8329            'meta': self.meta,
8330            'node': self.node,
8331            'rate_limit': self.rate_limit,
8332            'token': self.token,
8333        }
8334
8335    @classmethod
8336    def from_dict(cls, d):
8337        return cls(
8338            meta=d.get('meta'),
8339            node=d.get('node'),
8340            rate_limit=d.get('rate_limit'),
8341            token=d.get('token'),
8342        )

NodeCreateResponse reports how the Nodes were created in the system.

#   NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
View Source
8294    def __init__(
8295        self,
8296        meta=None,
8297        node=None,
8298        rate_limit=None,
8299        token=None,
8300    ):
8301        self.meta = meta if meta is not None else None
8302        '''
8303         Reserved for future use.
8304        '''
8305        self.node = node if node is not None else None
8306        '''
8307         The created Node.
8308        '''
8309        self.rate_limit = rate_limit if rate_limit is not None else None
8310        '''
8311         Rate limit information.
8312        '''
8313        self.token = token if token is not None else ''
8314        '''
8315         The auth token generated for the Node. The Node will use this token to
8316         authenticate with the strongDM API.
8317        '''
#   meta

Reserved for future use.

#   node

The created Node.

#   rate_limit

Rate limit information.

#   token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

#   def to_dict(self):
View Source
8327    def to_dict(self):
8328        return {
8329            'meta': self.meta,
8330            'node': self.node,
8331            'rate_limit': self.rate_limit,
8332            'token': self.token,
8333        }
#  
@classmethod
def from_dict(cls, d):
View Source
8335    @classmethod
8336    def from_dict(cls, d):
8337        return cls(
8338            meta=d.get('meta'),
8339            node=d.get('node'),
8340            rate_limit=d.get('rate_limit'),
8341            token=d.get('token'),
8342        )
#   class NodeDeleteResponse:
View Source
8345class NodeDeleteResponse:
8346    '''
8347     NodeDeleteResponse returns information about a Node that was deleted.
8348    '''
8349    __slots__ = [
8350        'meta',
8351        'rate_limit',
8352    ]
8353
8354    def __init__(
8355        self,
8356        meta=None,
8357        rate_limit=None,
8358    ):
8359        self.meta = meta if meta is not None else None
8360        '''
8361         Reserved for future use.
8362        '''
8363        self.rate_limit = rate_limit if rate_limit is not None else None
8364        '''
8365         Rate limit information.
8366        '''
8367
8368    def __repr__(self):
8369        return '<sdm.NodeDeleteResponse ' + \
8370            'meta: ' + repr(self.meta) + ' ' +\
8371            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8372            '>'
8373
8374    def to_dict(self):
8375        return {
8376            'meta': self.meta,
8377            'rate_limit': self.rate_limit,
8378        }
8379
8380    @classmethod
8381    def from_dict(cls, d):
8382        return cls(
8383            meta=d.get('meta'),
8384            rate_limit=d.get('rate_limit'),
8385        )

NodeDeleteResponse returns information about a Node that was deleted.

#   NodeDeleteResponse(meta=None, rate_limit=None)
View Source
8354    def __init__(
8355        self,
8356        meta=None,
8357        rate_limit=None,
8358    ):
8359        self.meta = meta if meta is not None else None
8360        '''
8361         Reserved for future use.
8362        '''
8363        self.rate_limit = rate_limit if rate_limit is not None else None
8364        '''
8365         Rate limit information.
8366        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
8374    def to_dict(self):
8375        return {
8376            'meta': self.meta,
8377            'rate_limit': self.rate_limit,
8378        }
#  
@classmethod
def from_dict(cls, d):
View Source
8380    @classmethod
8381    def from_dict(cls, d):
8382        return cls(
8383            meta=d.get('meta'),
8384            rate_limit=d.get('rate_limit'),
8385        )
#   class NodeGetResponse:
View Source
8388class NodeGetResponse:
8389    '''
8390     NodeGetResponse returns a requested Node.
8391    '''
8392    __slots__ = [
8393        'meta',
8394        'node',
8395        'rate_limit',
8396    ]
8397
8398    def __init__(
8399        self,
8400        meta=None,
8401        node=None,
8402        rate_limit=None,
8403    ):
8404        self.meta = meta if meta is not None else None
8405        '''
8406         Reserved for future use.
8407        '''
8408        self.node = node if node is not None else None
8409        '''
8410         The requested Node.
8411        '''
8412        self.rate_limit = rate_limit if rate_limit is not None else None
8413        '''
8414         Rate limit information.
8415        '''
8416
8417    def __repr__(self):
8418        return '<sdm.NodeGetResponse ' + \
8419            'meta: ' + repr(self.meta) + ' ' +\
8420            'node: ' + repr(self.node) + ' ' +\
8421            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8422            '>'
8423
8424    def to_dict(self):
8425        return {
8426            'meta': self.meta,
8427            'node': self.node,
8428            'rate_limit': self.rate_limit,
8429        }
8430
8431    @classmethod
8432    def from_dict(cls, d):
8433        return cls(
8434            meta=d.get('meta'),
8435            node=d.get('node'),
8436            rate_limit=d.get('rate_limit'),
8437        )

NodeGetResponse returns a requested Node.

#   NodeGetResponse(meta=None, node=None, rate_limit=None)
View Source
8398    def __init__(
8399        self,
8400        meta=None,
8401        node=None,
8402        rate_limit=None,
8403    ):
8404        self.meta = meta if meta is not None else None
8405        '''
8406         Reserved for future use.
8407        '''
8408        self.node = node if node is not None else None
8409        '''
8410         The requested Node.
8411        '''
8412        self.rate_limit = rate_limit if rate_limit is not None else None
8413        '''
8414         Rate limit information.
8415        '''
#   meta

Reserved for future use.

#   node

The requested Node.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
8424    def to_dict(self):
8425        return {
8426            'meta': self.meta,
8427            'node': self.node,
8428            'rate_limit': self.rate_limit,
8429        }
#  
@classmethod
def from_dict(cls, d):
View Source
8431    @classmethod
8432    def from_dict(cls, d):
8433        return cls(
8434            meta=d.get('meta'),
8435            node=d.get('node'),
8436            rate_limit=d.get('rate_limit'),
8437        )
#   class NodeUpdateResponse:
View Source
8440class NodeUpdateResponse:
8441    '''
8442     NodeUpdateResponse returns the fields of a Node after it has been updated by
8443     a NodeUpdateRequest.
8444    '''
8445    __slots__ = [
8446        'meta',
8447        'node',
8448        'rate_limit',
8449    ]
8450
8451    def __init__(
8452        self,
8453        meta=None,
8454        node=None,
8455        rate_limit=None,
8456    ):
8457        self.meta = meta if meta is not None else None
8458        '''
8459         Reserved for future use.
8460        '''
8461        self.node = node if node is not None else None
8462        '''
8463         The updated Node.
8464        '''
8465        self.rate_limit = rate_limit if rate_limit is not None else None
8466        '''
8467         Rate limit information.
8468        '''
8469
8470    def __repr__(self):
8471        return '<sdm.NodeUpdateResponse ' + \
8472            'meta: ' + repr(self.meta) + ' ' +\
8473            'node: ' + repr(self.node) + ' ' +\
8474            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8475            '>'
8476
8477    def to_dict(self):
8478        return {
8479            'meta': self.meta,
8480            'node': self.node,
8481            'rate_limit': self.rate_limit,
8482        }
8483
8484    @classmethod
8485    def from_dict(cls, d):
8486        return cls(
8487            meta=d.get('meta'),
8488            node=d.get('node'),
8489            rate_limit=d.get('rate_limit'),
8490        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

#   NodeUpdateResponse(meta=None, node=None, rate_limit=None)
View Source
8451    def __init__(
8452        self,
8453        meta=None,
8454        node=None,
8455        rate_limit=None,
8456    ):
8457        self.meta = meta if meta is not None else None
8458        '''
8459         Reserved for future use.
8460        '''
8461        self.node = node if node is not None else None
8462        '''
8463         The updated Node.
8464        '''
8465        self.rate_limit = rate_limit if rate_limit is not None else None
8466        '''
8467         Rate limit information.
8468        '''
#   meta

Reserved for future use.

#   node

The updated Node.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
8477    def to_dict(self):
8478        return {
8479            'meta': self.meta,
8480            'node': self.node,
8481            'rate_limit': self.rate_limit,
8482        }
#  
@classmethod
def from_dict(cls, d):
View Source
8484    @classmethod
8485    def from_dict(cls, d):
8486        return cls(
8487            meta=d.get('meta'),
8488            node=d.get('node'),
8489            rate_limit=d.get('rate_limit'),
8490        )
#   class Oracle:
View Source
8493class Oracle:
8494    '''
8495
8496    '''
8497    __slots__ = [
8498        'database',
8499        'egress_filter',
8500        'healthy',
8501        'hostname',
8502        'id',
8503        'name',
8504        'password',
8505        'port',
8506        'port_override',
8507        'secret_store_id',
8508        'tags',
8509        'tls_required',
8510        'username',
8511    ]
8512
8513    def __init__(
8514        self,
8515        database=None,
8516        egress_filter=None,
8517        healthy=None,
8518        hostname=None,
8519        id=None,
8520        name=None,
8521        password=None,
8522        port=None,
8523        port_override=None,
8524        secret_store_id=None,
8525        tags=None,
8526        tls_required=None,
8527        username=None,
8528    ):
8529        self.database = database if database is not None else ''
8530        '''
8531
8532        '''
8533        self.egress_filter = egress_filter if egress_filter is not None else ''
8534        '''
8535         A filter applied to the routing logic to pin datasource to nodes.
8536        '''
8537        self.healthy = healthy if healthy is not None else False
8538        '''
8539         True if the datasource is reachable and the credentials are valid.
8540        '''
8541        self.hostname = hostname if hostname is not None else ''
8542        '''
8543
8544        '''
8545        self.id = id if id is not None else ''
8546        '''
8547         Unique identifier of the Resource.
8548        '''
8549        self.name = name if name is not None else ''
8550        '''
8551         Unique human-readable name of the Resource.
8552        '''
8553        self.password = password if password is not None else ''
8554        '''
8555
8556        '''
8557        self.port = port if port is not None else 0
8558        '''
8559
8560        '''
8561        self.port_override = port_override if port_override is not None else 0
8562        '''
8563
8564        '''
8565        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8566        '''
8567         ID of the secret store containing credentials for this resource, if any.
8568        '''
8569        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8570        '''
8571         Tags is a map of key, value pairs.
8572        '''
8573        self.tls_required = tls_required if tls_required is not None else False
8574        '''
8575
8576        '''
8577        self.username = username if username is not None else ''
8578        '''
8579
8580        '''
8581
8582    def __repr__(self):
8583        return '<sdm.Oracle ' + \
8584            'database: ' + repr(self.database) + ' ' +\
8585            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8586            'healthy: ' + repr(self.healthy) + ' ' +\
8587            'hostname: ' + repr(self.hostname) + ' ' +\
8588            'id: ' + repr(self.id) + ' ' +\
8589            'name: ' + repr(self.name) + ' ' +\
8590            'password: ' + repr(self.password) + ' ' +\
8591            'port: ' + repr(self.port) + ' ' +\
8592            'port_override: ' + repr(self.port_override) + ' ' +\
8593            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8594            'tags: ' + repr(self.tags) + ' ' +\
8595            'tls_required: ' + repr(self.tls_required) + ' ' +\
8596            'username: ' + repr(self.username) + ' ' +\
8597            '>'
8598
8599    def to_dict(self):
8600        return {
8601            'database': self.database,
8602            'egress_filter': self.egress_filter,
8603            'healthy': self.healthy,
8604            'hostname': self.hostname,
8605            'id': self.id,
8606            'name': self.name,
8607            'password': self.password,
8608            'port': self.port,
8609            'port_override': self.port_override,
8610            'secret_store_id': self.secret_store_id,
8611            'tags': self.tags,
8612            'tls_required': self.tls_required,
8613            'username': self.username,
8614        }
8615
8616    @classmethod
8617    def from_dict(cls, d):
8618        return cls(
8619            database=d.get('database'),
8620            egress_filter=d.get('egress_filter'),
8621            healthy=d.get('healthy'),
8622            hostname=d.get('hostname'),
8623            id=d.get('id'),
8624            name=d.get('name'),
8625            password=d.get('password'),
8626            port=d.get('port'),
8627            port_override=d.get('port_override'),
8628            secret_store_id=d.get('secret_store_id'),
8629            tags=d.get('tags'),
8630            tls_required=d.get('tls_required'),
8631            username=d.get('username'),
8632        )
#   Oracle( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
8513    def __init__(
8514        self,
8515        database=None,
8516        egress_filter=None,
8517        healthy=None,
8518        hostname=None,
8519        id=None,
8520        name=None,
8521        password=None,
8522        port=None,
8523        port_override=None,
8524        secret_store_id=None,
8525        tags=None,
8526        tls_required=None,
8527        username=None,
8528    ):
8529        self.database = database if database is not None else ''
8530        '''
8531
8532        '''
8533        self.egress_filter = egress_filter if egress_filter is not None else ''
8534        '''
8535         A filter applied to the routing logic to pin datasource to nodes.
8536        '''
8537        self.healthy = healthy if healthy is not None else False
8538        '''
8539         True if the datasource is reachable and the credentials are valid.
8540        '''
8541        self.hostname = hostname if hostname is not None else ''
8542        '''
8543
8544        '''
8545        self.id = id if id is not None else ''
8546        '''
8547         Unique identifier of the Resource.
8548        '''
8549        self.name = name if name is not None else ''
8550        '''
8551         Unique human-readable name of the Resource.
8552        '''
8553        self.password = password if password is not None else ''
8554        '''
8555
8556        '''
8557        self.port = port if port is not None else 0
8558        '''
8559
8560        '''
8561        self.port_override = port_override if port_override is not None else 0
8562        '''
8563
8564        '''
8565        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8566        '''
8567         ID of the secret store containing credentials for this resource, if any.
8568        '''
8569        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8570        '''
8571         Tags is a map of key, value pairs.
8572        '''
8573        self.tls_required = tls_required if tls_required is not None else False
8574        '''
8575
8576        '''
8577        self.username = username if username is not None else ''
8578        '''
8579
8580        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
8599    def to_dict(self):
8600        return {
8601            'database': self.database,
8602            'egress_filter': self.egress_filter,
8603            'healthy': self.healthy,
8604            'hostname': self.hostname,
8605            'id': self.id,
8606            'name': self.name,
8607            'password': self.password,
8608            'port': self.port,
8609            'port_override': self.port_override,
8610            'secret_store_id': self.secret_store_id,
8611            'tags': self.tags,
8612            'tls_required': self.tls_required,
8613            'username': self.username,
8614        }
#  
@classmethod
def from_dict(cls, d):
View Source
8616    @classmethod
8617    def from_dict(cls, d):
8618        return cls(
8619            database=d.get('database'),
8620            egress_filter=d.get('egress_filter'),
8621            healthy=d.get('healthy'),
8622            hostname=d.get('hostname'),
8623            id=d.get('id'),
8624            name=d.get('name'),
8625            password=d.get('password'),
8626            port=d.get('port'),
8627            port_override=d.get('port_override'),
8628            secret_store_id=d.get('secret_store_id'),
8629            tags=d.get('tags'),
8630            tls_required=d.get('tls_required'),
8631            username=d.get('username'),
8632        )
#   class Postgres:
View Source
8635class Postgres:
8636    '''
8637
8638    '''
8639    __slots__ = [
8640        'database',
8641        'egress_filter',
8642        'healthy',
8643        'hostname',
8644        'id',
8645        'name',
8646        'override_database',
8647        'password',
8648        'port',
8649        'port_override',
8650        'secret_store_id',
8651        'tags',
8652        'username',
8653    ]
8654
8655    def __init__(
8656        self,
8657        database=None,
8658        egress_filter=None,
8659        healthy=None,
8660        hostname=None,
8661        id=None,
8662        name=None,
8663        override_database=None,
8664        password=None,
8665        port=None,
8666        port_override=None,
8667        secret_store_id=None,
8668        tags=None,
8669        username=None,
8670    ):
8671        self.database = database if database is not None else ''
8672        '''
8673
8674        '''
8675        self.egress_filter = egress_filter if egress_filter is not None else ''
8676        '''
8677         A filter applied to the routing logic to pin datasource to nodes.
8678        '''
8679        self.healthy = healthy if healthy is not None else False
8680        '''
8681         True if the datasource is reachable and the credentials are valid.
8682        '''
8683        self.hostname = hostname if hostname is not None else ''
8684        '''
8685
8686        '''
8687        self.id = id if id is not None else ''
8688        '''
8689         Unique identifier of the Resource.
8690        '''
8691        self.name = name if name is not None else ''
8692        '''
8693         Unique human-readable name of the Resource.
8694        '''
8695        self.override_database = override_database if override_database is not None else False
8696        '''
8697
8698        '''
8699        self.password = password if password is not None else ''
8700        '''
8701
8702        '''
8703        self.port = port if port is not None else 0
8704        '''
8705
8706        '''
8707        self.port_override = port_override if port_override is not None else 0
8708        '''
8709
8710        '''
8711        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8712        '''
8713         ID of the secret store containing credentials for this resource, if any.
8714        '''
8715        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8716        '''
8717         Tags is a map of key, value pairs.
8718        '''
8719        self.username = username if username is not None else ''
8720        '''
8721
8722        '''
8723
8724    def __repr__(self):
8725        return '<sdm.Postgres ' + \
8726            'database: ' + repr(self.database) + ' ' +\
8727            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8728            'healthy: ' + repr(self.healthy) + ' ' +\
8729            'hostname: ' + repr(self.hostname) + ' ' +\
8730            'id: ' + repr(self.id) + ' ' +\
8731            'name: ' + repr(self.name) + ' ' +\
8732            'override_database: ' + repr(self.override_database) + ' ' +\
8733            'password: ' + repr(self.password) + ' ' +\
8734            'port: ' + repr(self.port) + ' ' +\
8735            'port_override: ' + repr(self.port_override) + ' ' +\
8736            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8737            'tags: ' + repr(self.tags) + ' ' +\
8738            'username: ' + repr(self.username) + ' ' +\
8739            '>'
8740
8741    def to_dict(self):
8742        return {
8743            'database': self.database,
8744            'egress_filter': self.egress_filter,
8745            'healthy': self.healthy,
8746            'hostname': self.hostname,
8747            'id': self.id,
8748            'name': self.name,
8749            'override_database': self.override_database,
8750            'password': self.password,
8751            'port': self.port,
8752            'port_override': self.port_override,
8753            'secret_store_id': self.secret_store_id,
8754            'tags': self.tags,
8755            'username': self.username,
8756        }
8757
8758    @classmethod
8759    def from_dict(cls, d):
8760        return cls(
8761            database=d.get('database'),
8762            egress_filter=d.get('egress_filter'),
8763            healthy=d.get('healthy'),
8764            hostname=d.get('hostname'),
8765            id=d.get('id'),
8766            name=d.get('name'),
8767            override_database=d.get('override_database'),
8768            password=d.get('password'),
8769            port=d.get('port'),
8770            port_override=d.get('port_override'),
8771            secret_store_id=d.get('secret_store_id'),
8772            tags=d.get('tags'),
8773            username=d.get('username'),
8774        )
#   Postgres( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
8655    def __init__(
8656        self,
8657        database=None,
8658        egress_filter=None,
8659        healthy=None,
8660        hostname=None,
8661        id=None,
8662        name=None,
8663        override_database=None,
8664        password=None,
8665        port=None,
8666        port_override=None,
8667        secret_store_id=None,
8668        tags=None,
8669        username=None,
8670    ):
8671        self.database = database if database is not None else ''
8672        '''
8673
8674        '''
8675        self.egress_filter = egress_filter if egress_filter is not None else ''
8676        '''
8677         A filter applied to the routing logic to pin datasource to nodes.
8678        '''
8679        self.healthy = healthy if healthy is not None else False
8680        '''
8681         True if the datasource is reachable and the credentials are valid.
8682        '''
8683        self.hostname = hostname if hostname is not None else ''
8684        '''
8685
8686        '''
8687        self.id = id if id is not None else ''
8688        '''
8689         Unique identifier of the Resource.
8690        '''
8691        self.name = name if name is not None else ''
8692        '''
8693         Unique human-readable name of the Resource.
8694        '''
8695        self.override_database = override_database if override_database is not None else False
8696        '''
8697
8698        '''
8699        self.password = password if password is not None else ''
8700        '''
8701
8702        '''
8703        self.port = port if port is not None else 0
8704        '''
8705
8706        '''
8707        self.port_override = port_override if port_override is not None else 0
8708        '''
8709
8710        '''
8711        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8712        '''
8713         ID of the secret store containing credentials for this resource, if any.
8714        '''
8715        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8716        '''
8717         Tags is a map of key, value pairs.
8718        '''
8719        self.username = username if username is not None else ''
8720        '''
8721
8722        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
8741    def to_dict(self):
8742        return {
8743            'database': self.database,
8744            'egress_filter': self.egress_filter,
8745            'healthy': self.healthy,
8746            'hostname': self.hostname,
8747            'id': self.id,
8748            'name': self.name,
8749            'override_database': self.override_database,
8750            'password': self.password,
8751            'port': self.port,
8752            'port_override': self.port_override,
8753            'secret_store_id': self.secret_store_id,
8754            'tags': self.tags,
8755            'username': self.username,
8756        }
#  
@classmethod
def from_dict(cls, d):
View Source
8758    @classmethod
8759    def from_dict(cls, d):
8760        return cls(
8761            database=d.get('database'),
8762            egress_filter=d.get('egress_filter'),
8763            healthy=d.get('healthy'),
8764            hostname=d.get('hostname'),
8765            id=d.get('id'),
8766            name=d.get('name'),
8767            override_database=d.get('override_database'),
8768            password=d.get('password'),
8769            port=d.get('port'),
8770            port_override=d.get('port_override'),
8771            secret_store_id=d.get('secret_store_id'),
8772            tags=d.get('tags'),
8773            username=d.get('username'),
8774        )
#   class Presto:
View Source
8777class Presto:
8778    '''
8779
8780    '''
8781    __slots__ = [
8782        'database',
8783        'egress_filter',
8784        'healthy',
8785        'hostname',
8786        'id',
8787        'name',
8788        'password',
8789        'port',
8790        'port_override',
8791        'secret_store_id',
8792        'tags',
8793        'tls_required',
8794        'username',
8795    ]
8796
8797    def __init__(
8798        self,
8799        database=None,
8800        egress_filter=None,
8801        healthy=None,
8802        hostname=None,
8803        id=None,
8804        name=None,
8805        password=None,
8806        port=None,
8807        port_override=None,
8808        secret_store_id=None,
8809        tags=None,
8810        tls_required=None,
8811        username=None,
8812    ):
8813        self.database = database if database is not None else ''
8814        '''
8815
8816        '''
8817        self.egress_filter = egress_filter if egress_filter is not None else ''
8818        '''
8819         A filter applied to the routing logic to pin datasource to nodes.
8820        '''
8821        self.healthy = healthy if healthy is not None else False
8822        '''
8823         True if the datasource is reachable and the credentials are valid.
8824        '''
8825        self.hostname = hostname if hostname is not None else ''
8826        '''
8827
8828        '''
8829        self.id = id if id is not None else ''
8830        '''
8831         Unique identifier of the Resource.
8832        '''
8833        self.name = name if name is not None else ''
8834        '''
8835         Unique human-readable name of the Resource.
8836        '''
8837        self.password = password if password is not None else ''
8838        '''
8839
8840        '''
8841        self.port = port if port is not None else 0
8842        '''
8843
8844        '''
8845        self.port_override = port_override if port_override is not None else 0
8846        '''
8847
8848        '''
8849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8850        '''
8851         ID of the secret store containing credentials for this resource, if any.
8852        '''
8853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8854        '''
8855         Tags is a map of key, value pairs.
8856        '''
8857        self.tls_required = tls_required if tls_required is not None else False
8858        '''
8859
8860        '''
8861        self.username = username if username is not None else ''
8862        '''
8863
8864        '''
8865
8866    def __repr__(self):
8867        return '<sdm.Presto ' + \
8868            'database: ' + repr(self.database) + ' ' +\
8869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8870            'healthy: ' + repr(self.healthy) + ' ' +\
8871            'hostname: ' + repr(self.hostname) + ' ' +\
8872            'id: ' + repr(self.id) + ' ' +\
8873            'name: ' + repr(self.name) + ' ' +\
8874            'password: ' + repr(self.password) + ' ' +\
8875            'port: ' + repr(self.port) + ' ' +\
8876            'port_override: ' + repr(self.port_override) + ' ' +\
8877            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8878            'tags: ' + repr(self.tags) + ' ' +\
8879            'tls_required: ' + repr(self.tls_required) + ' ' +\
8880            'username: ' + repr(self.username) + ' ' +\
8881            '>'
8882
8883    def to_dict(self):
8884        return {
8885            'database': self.database,
8886            'egress_filter': self.egress_filter,
8887            'healthy': self.healthy,
8888            'hostname': self.hostname,
8889            'id': self.id,
8890            'name': self.name,
8891            'password': self.password,
8892            'port': self.port,
8893            'port_override': self.port_override,
8894            'secret_store_id': self.secret_store_id,
8895            'tags': self.tags,
8896            'tls_required': self.tls_required,
8897            'username': self.username,
8898        }
8899
8900    @classmethod
8901    def from_dict(cls, d):
8902        return cls(
8903            database=d.get('database'),
8904            egress_filter=d.get('egress_filter'),
8905            healthy=d.get('healthy'),
8906            hostname=d.get('hostname'),
8907            id=d.get('id'),
8908            name=d.get('name'),
8909            password=d.get('password'),
8910            port=d.get('port'),
8911            port_override=d.get('port_override'),
8912            secret_store_id=d.get('secret_store_id'),
8913            tags=d.get('tags'),
8914            tls_required=d.get('tls_required'),
8915            username=d.get('username'),
8916        )
#   Presto( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
8797    def __init__(
8798        self,
8799        database=None,
8800        egress_filter=None,
8801        healthy=None,
8802        hostname=None,
8803        id=None,
8804        name=None,
8805        password=None,
8806        port=None,
8807        port_override=None,
8808        secret_store_id=None,
8809        tags=None,
8810        tls_required=None,
8811        username=None,
8812    ):
8813        self.database = database if database is not None else ''
8814        '''
8815
8816        '''
8817        self.egress_filter = egress_filter if egress_filter is not None else ''
8818        '''
8819         A filter applied to the routing logic to pin datasource to nodes.
8820        '''
8821        self.healthy = healthy if healthy is not None else False
8822        '''
8823         True if the datasource is reachable and the credentials are valid.
8824        '''
8825        self.hostname = hostname if hostname is not None else ''
8826        '''
8827
8828        '''
8829        self.id = id if id is not None else ''
8830        '''
8831         Unique identifier of the Resource.
8832        '''
8833        self.name = name if name is not None else ''
8834        '''
8835         Unique human-readable name of the Resource.
8836        '''
8837        self.password = password if password is not None else ''
8838        '''
8839
8840        '''
8841        self.port = port if port is not None else 0
8842        '''
8843
8844        '''
8845        self.port_override = port_override if port_override is not None else 0
8846        '''
8847
8848        '''
8849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8850        '''
8851         ID of the secret store containing credentials for this resource, if any.
8852        '''
8853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8854        '''
8855         Tags is a map of key, value pairs.
8856        '''
8857        self.tls_required = tls_required if tls_required is not None else False
8858        '''
8859
8860        '''
8861        self.username = username if username is not None else ''
8862        '''
8863
8864        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
8883    def to_dict(self):
8884        return {
8885            'database': self.database,
8886            'egress_filter': self.egress_filter,
8887            'healthy': self.healthy,
8888            'hostname': self.hostname,
8889            'id': self.id,
8890            'name': self.name,
8891            'password': self.password,
8892            'port': self.port,
8893            'port_override': self.port_override,
8894            'secret_store_id': self.secret_store_id,
8895            'tags': self.tags,
8896            'tls_required': self.tls_required,
8897            'username': self.username,
8898        }
#  
@classmethod
def from_dict(cls, d):
View Source
8900    @classmethod
8901    def from_dict(cls, d):
8902        return cls(
8903            database=d.get('database'),
8904            egress_filter=d.get('egress_filter'),
8905            healthy=d.get('healthy'),
8906            hostname=d.get('hostname'),
8907            id=d.get('id'),
8908            name=d.get('name'),
8909            password=d.get('password'),
8910            port=d.get('port'),
8911            port_override=d.get('port_override'),
8912            secret_store_id=d.get('secret_store_id'),
8913            tags=d.get('tags'),
8914            tls_required=d.get('tls_required'),
8915            username=d.get('username'),
8916        )
#   class RDP:
View Source
8919class RDP:
8920    '''
8921
8922    '''
8923    __slots__ = [
8924        'downgrade_nla_connections',
8925        'egress_filter',
8926        'healthy',
8927        'hostname',
8928        'id',
8929        'name',
8930        'password',
8931        'port',
8932        'port_override',
8933        'secret_store_id',
8934        'tags',
8935        'username',
8936    ]
8937
8938    def __init__(
8939        self,
8940        downgrade_nla_connections=None,
8941        egress_filter=None,
8942        healthy=None,
8943        hostname=None,
8944        id=None,
8945        name=None,
8946        password=None,
8947        port=None,
8948        port_override=None,
8949        secret_store_id=None,
8950        tags=None,
8951        username=None,
8952    ):
8953        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8954        '''
8955
8956        '''
8957        self.egress_filter = egress_filter if egress_filter is not None else ''
8958        '''
8959         A filter applied to the routing logic to pin datasource to nodes.
8960        '''
8961        self.healthy = healthy if healthy is not None else False
8962        '''
8963         True if the datasource is reachable and the credentials are valid.
8964        '''
8965        self.hostname = hostname if hostname is not None else ''
8966        '''
8967
8968        '''
8969        self.id = id if id is not None else ''
8970        '''
8971         Unique identifier of the Resource.
8972        '''
8973        self.name = name if name is not None else ''
8974        '''
8975         Unique human-readable name of the Resource.
8976        '''
8977        self.password = password if password is not None else ''
8978        '''
8979
8980        '''
8981        self.port = port if port is not None else 0
8982        '''
8983
8984        '''
8985        self.port_override = port_override if port_override is not None else 0
8986        '''
8987
8988        '''
8989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8990        '''
8991         ID of the secret store containing credentials for this resource, if any.
8992        '''
8993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8994        '''
8995         Tags is a map of key, value pairs.
8996        '''
8997        self.username = username if username is not None else ''
8998        '''
8999
9000        '''
9001
9002    def __repr__(self):
9003        return '<sdm.RDP ' + \
9004            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9005            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9006            'healthy: ' + repr(self.healthy) + ' ' +\
9007            'hostname: ' + repr(self.hostname) + ' ' +\
9008            'id: ' + repr(self.id) + ' ' +\
9009            'name: ' + repr(self.name) + ' ' +\
9010            'password: ' + repr(self.password) + ' ' +\
9011            'port: ' + repr(self.port) + ' ' +\
9012            'port_override: ' + repr(self.port_override) + ' ' +\
9013            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9014            'tags: ' + repr(self.tags) + ' ' +\
9015            'username: ' + repr(self.username) + ' ' +\
9016            '>'
9017
9018    def to_dict(self):
9019        return {
9020            'downgrade_nla_connections': self.downgrade_nla_connections,
9021            'egress_filter': self.egress_filter,
9022            'healthy': self.healthy,
9023            'hostname': self.hostname,
9024            'id': self.id,
9025            'name': self.name,
9026            'password': self.password,
9027            'port': self.port,
9028            'port_override': self.port_override,
9029            'secret_store_id': self.secret_store_id,
9030            'tags': self.tags,
9031            'username': self.username,
9032        }
9033
9034    @classmethod
9035    def from_dict(cls, d):
9036        return cls(
9037            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9038            egress_filter=d.get('egress_filter'),
9039            healthy=d.get('healthy'),
9040            hostname=d.get('hostname'),
9041            id=d.get('id'),
9042            name=d.get('name'),
9043            password=d.get('password'),
9044            port=d.get('port'),
9045            port_override=d.get('port_override'),
9046            secret_store_id=d.get('secret_store_id'),
9047            tags=d.get('tags'),
9048            username=d.get('username'),
9049        )
#   RDP( downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
8938    def __init__(
8939        self,
8940        downgrade_nla_connections=None,
8941        egress_filter=None,
8942        healthy=None,
8943        hostname=None,
8944        id=None,
8945        name=None,
8946        password=None,
8947        port=None,
8948        port_override=None,
8949        secret_store_id=None,
8950        tags=None,
8951        username=None,
8952    ):
8953        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8954        '''
8955
8956        '''
8957        self.egress_filter = egress_filter if egress_filter is not None else ''
8958        '''
8959         A filter applied to the routing logic to pin datasource to nodes.
8960        '''
8961        self.healthy = healthy if healthy is not None else False
8962        '''
8963         True if the datasource is reachable and the credentials are valid.
8964        '''
8965        self.hostname = hostname if hostname is not None else ''
8966        '''
8967
8968        '''
8969        self.id = id if id is not None else ''
8970        '''
8971         Unique identifier of the Resource.
8972        '''
8973        self.name = name if name is not None else ''
8974        '''
8975         Unique human-readable name of the Resource.
8976        '''
8977        self.password = password if password is not None else ''
8978        '''
8979
8980        '''
8981        self.port = port if port is not None else 0
8982        '''
8983
8984        '''
8985        self.port_override = port_override if port_override is not None else 0
8986        '''
8987
8988        '''
8989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8990        '''
8991         ID of the secret store containing credentials for this resource, if any.
8992        '''
8993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8994        '''
8995         Tags is a map of key, value pairs.
8996        '''
8997        self.username = username if username is not None else ''
8998        '''
8999
9000        '''
#   downgrade_nla_connections
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
9018    def to_dict(self):
9019        return {
9020            'downgrade_nla_connections': self.downgrade_nla_connections,
9021            'egress_filter': self.egress_filter,
9022            'healthy': self.healthy,
9023            'hostname': self.hostname,
9024            'id': self.id,
9025            'name': self.name,
9026            'password': self.password,
9027            'port': self.port,
9028            'port_override': self.port_override,
9029            'secret_store_id': self.secret_store_id,
9030            'tags': self.tags,
9031            'username': self.username,
9032        }
#  
@classmethod
def from_dict(cls, d):
View Source
9034    @classmethod
9035    def from_dict(cls, d):
9036        return cls(
9037            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9038            egress_filter=d.get('egress_filter'),
9039            healthy=d.get('healthy'),
9040            hostname=d.get('hostname'),
9041            id=d.get('id'),
9042            name=d.get('name'),
9043            password=d.get('password'),
9044            port=d.get('port'),
9045            port_override=d.get('port_override'),
9046            secret_store_id=d.get('secret_store_id'),
9047            tags=d.get('tags'),
9048            username=d.get('username'),
9049        )
#   class RabbitMQAMQP091:
View Source
9052class RabbitMQAMQP091:
9053    '''
9054
9055    '''
9056    __slots__ = [
9057        'egress_filter',
9058        'healthy',
9059        'hostname',
9060        'id',
9061        'name',
9062        'password',
9063        'port',
9064        'port_override',
9065        'secret_store_id',
9066        'tags',
9067        'tls_required',
9068        'username',
9069    ]
9070
9071    def __init__(
9072        self,
9073        egress_filter=None,
9074        healthy=None,
9075        hostname=None,
9076        id=None,
9077        name=None,
9078        password=None,
9079        port=None,
9080        port_override=None,
9081        secret_store_id=None,
9082        tags=None,
9083        tls_required=None,
9084        username=None,
9085    ):
9086        self.egress_filter = egress_filter if egress_filter is not None else ''
9087        '''
9088         A filter applied to the routing logic to pin datasource to nodes.
9089        '''
9090        self.healthy = healthy if healthy is not None else False
9091        '''
9092         True if the datasource is reachable and the credentials are valid.
9093        '''
9094        self.hostname = hostname if hostname is not None else ''
9095        '''
9096
9097        '''
9098        self.id = id if id is not None else ''
9099        '''
9100         Unique identifier of the Resource.
9101        '''
9102        self.name = name if name is not None else ''
9103        '''
9104         Unique human-readable name of the Resource.
9105        '''
9106        self.password = password if password is not None else ''
9107        '''
9108
9109        '''
9110        self.port = port if port is not None else 0
9111        '''
9112
9113        '''
9114        self.port_override = port_override if port_override is not None else 0
9115        '''
9116
9117        '''
9118        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9119        '''
9120         ID of the secret store containing credentials for this resource, if any.
9121        '''
9122        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9123        '''
9124         Tags is a map of key, value pairs.
9125        '''
9126        self.tls_required = tls_required if tls_required is not None else False
9127        '''
9128
9129        '''
9130        self.username = username if username is not None else ''
9131        '''
9132
9133        '''
9134
9135    def __repr__(self):
9136        return '<sdm.RabbitMQAMQP091 ' + \
9137            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9138            'healthy: ' + repr(self.healthy) + ' ' +\
9139            'hostname: ' + repr(self.hostname) + ' ' +\
9140            'id: ' + repr(self.id) + ' ' +\
9141            'name: ' + repr(self.name) + ' ' +\
9142            'password: ' + repr(self.password) + ' ' +\
9143            'port: ' + repr(self.port) + ' ' +\
9144            'port_override: ' + repr(self.port_override) + ' ' +\
9145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9146            'tags: ' + repr(self.tags) + ' ' +\
9147            'tls_required: ' + repr(self.tls_required) + ' ' +\
9148            'username: ' + repr(self.username) + ' ' +\
9149            '>'
9150
9151    def to_dict(self):
9152        return {
9153            'egress_filter': self.egress_filter,
9154            'healthy': self.healthy,
9155            'hostname': self.hostname,
9156            'id': self.id,
9157            'name': self.name,
9158            'password': self.password,
9159            'port': self.port,
9160            'port_override': self.port_override,
9161            'secret_store_id': self.secret_store_id,
9162            'tags': self.tags,
9163            'tls_required': self.tls_required,
9164            'username': self.username,
9165        }
9166
9167    @classmethod
9168    def from_dict(cls, d):
9169        return cls(
9170            egress_filter=d.get('egress_filter'),
9171            healthy=d.get('healthy'),
9172            hostname=d.get('hostname'),
9173            id=d.get('id'),
9174            name=d.get('name'),
9175            password=d.get('password'),
9176            port=d.get('port'),
9177            port_override=d.get('port_override'),
9178            secret_store_id=d.get('secret_store_id'),
9179            tags=d.get('tags'),
9180            tls_required=d.get('tls_required'),
9181            username=d.get('username'),
9182        )
#   RabbitMQAMQP091( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None )
View Source
9071    def __init__(
9072        self,
9073        egress_filter=None,
9074        healthy=None,
9075        hostname=None,
9076        id=None,
9077        name=None,
9078        password=None,
9079        port=None,
9080        port_override=None,
9081        secret_store_id=None,
9082        tags=None,
9083        tls_required=None,
9084        username=None,
9085    ):
9086        self.egress_filter = egress_filter if egress_filter is not None else ''
9087        '''
9088         A filter applied to the routing logic to pin datasource to nodes.
9089        '''
9090        self.healthy = healthy if healthy is not None else False
9091        '''
9092         True if the datasource is reachable and the credentials are valid.
9093        '''
9094        self.hostname = hostname if hostname is not None else ''
9095        '''
9096
9097        '''
9098        self.id = id if id is not None else ''
9099        '''
9100         Unique identifier of the Resource.
9101        '''
9102        self.name = name if name is not None else ''
9103        '''
9104         Unique human-readable name of the Resource.
9105        '''
9106        self.password = password if password is not None else ''
9107        '''
9108
9109        '''
9110        self.port = port if port is not None else 0
9111        '''
9112
9113        '''
9114        self.port_override = port_override if port_override is not None else 0
9115        '''
9116
9117        '''
9118        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9119        '''
9120         ID of the secret store containing credentials for this resource, if any.
9121        '''
9122        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9123        '''
9124         Tags is a map of key, value pairs.
9125        '''
9126        self.tls_required = tls_required if tls_required is not None else False
9127        '''
9128
9129        '''
9130        self.username = username if username is not None else ''
9131        '''
9132
9133        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   tls_required
#   username
#   def to_dict(self):
View Source
9151    def to_dict(self):
9152        return {
9153            'egress_filter': self.egress_filter,
9154            'healthy': self.healthy,
9155            'hostname': self.hostname,
9156            'id': self.id,
9157            'name': self.name,
9158            'password': self.password,
9159            'port': self.port,
9160            'port_override': self.port_override,
9161            'secret_store_id': self.secret_store_id,
9162            'tags': self.tags,
9163            'tls_required': self.tls_required,
9164            'username': self.username,
9165        }
#  
@classmethod
def from_dict(cls, d):
View Source
9167    @classmethod
9168    def from_dict(cls, d):
9169        return cls(
9170            egress_filter=d.get('egress_filter'),
9171            healthy=d.get('healthy'),
9172            hostname=d.get('hostname'),
9173            id=d.get('id'),
9174            name=d.get('name'),
9175            password=d.get('password'),
9176            port=d.get('port'),
9177            port_override=d.get('port_override'),
9178            secret_store_id=d.get('secret_store_id'),
9179            tags=d.get('tags'),
9180            tls_required=d.get('tls_required'),
9181            username=d.get('username'),
9182        )
#   class RateLimitMetadata:
View Source
9185class RateLimitMetadata:
9186    '''
9187     RateLimitMetadata contains information about remaining requests avaialable
9188     to the user over some timeframe.
9189    '''
9190    __slots__ = [
9191        'bucket',
9192        'limit',
9193        'remaining',
9194        'reset_at',
9195    ]
9196
9197    def __init__(
9198        self,
9199        bucket=None,
9200        limit=None,
9201        remaining=None,
9202        reset_at=None,
9203    ):
9204        self.bucket = bucket if bucket is not None else ''
9205        '''
9206         The bucket this user/token is associated with, which may be shared between
9207         multiple users/tokens.
9208        '''
9209        self.limit = limit if limit is not None else 0
9210        '''
9211         How many total requests the user/token is authorized to make before being
9212         rate limited.
9213        '''
9214        self.remaining = remaining if remaining is not None else 0
9215        '''
9216         How many remaining requests out of the limit are still avaialable.
9217        '''
9218        self.reset_at = reset_at if reset_at is not None else None
9219        '''
9220         The time when remaining will be reset to limit.
9221        '''
9222
9223    def __repr__(self):
9224        return '<sdm.RateLimitMetadata ' + \
9225            'bucket: ' + repr(self.bucket) + ' ' +\
9226            'limit: ' + repr(self.limit) + ' ' +\
9227            'remaining: ' + repr(self.remaining) + ' ' +\
9228            'reset_at: ' + repr(self.reset_at) + ' ' +\
9229            '>'
9230
9231    def to_dict(self):
9232        return {
9233            'bucket': self.bucket,
9234            'limit': self.limit,
9235            'remaining': self.remaining,
9236            'reset_at': self.reset_at,
9237        }
9238
9239    @classmethod
9240    def from_dict(cls, d):
9241        return cls(
9242            bucket=d.get('bucket'),
9243            limit=d.get('limit'),
9244            remaining=d.get('remaining'),
9245            reset_at=d.get('reset_at'),
9246        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

#   RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
View Source
9197    def __init__(
9198        self,
9199        bucket=None,
9200        limit=None,
9201        remaining=None,
9202        reset_at=None,
9203    ):
9204        self.bucket = bucket if bucket is not None else ''
9205        '''
9206         The bucket this user/token is associated with, which may be shared between
9207         multiple users/tokens.
9208        '''
9209        self.limit = limit if limit is not None else 0
9210        '''
9211         How many total requests the user/token is authorized to make before being
9212         rate limited.
9213        '''
9214        self.remaining = remaining if remaining is not None else 0
9215        '''
9216         How many remaining requests out of the limit are still avaialable.
9217        '''
9218        self.reset_at = reset_at if reset_at is not None else None
9219        '''
9220         The time when remaining will be reset to limit.
9221        '''
#   bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

#   limit

How many total requests the user/token is authorized to make before being rate limited.

#   remaining

How many remaining requests out of the limit are still avaialable.

#   reset_at

The time when remaining will be reset to limit.

#   def to_dict(self):
View Source
9231    def to_dict(self):
9232        return {
9233            'bucket': self.bucket,
9234            'limit': self.limit,
9235            'remaining': self.remaining,
9236            'reset_at': self.reset_at,
9237        }
#  
@classmethod
def from_dict(cls, d):
View Source
9239    @classmethod
9240    def from_dict(cls, d):
9241        return cls(
9242            bucket=d.get('bucket'),
9243            limit=d.get('limit'),
9244            remaining=d.get('remaining'),
9245            reset_at=d.get('reset_at'),
9246        )
#   class RawTCP:
View Source
9249class RawTCP:
9250    '''
9251
9252    '''
9253    __slots__ = [
9254        'egress_filter',
9255        'healthy',
9256        'hostname',
9257        'id',
9258        'name',
9259        'port',
9260        'port_override',
9261        'secret_store_id',
9262        'tags',
9263    ]
9264
9265    def __init__(
9266        self,
9267        egress_filter=None,
9268        healthy=None,
9269        hostname=None,
9270        id=None,
9271        name=None,
9272        port=None,
9273        port_override=None,
9274        secret_store_id=None,
9275        tags=None,
9276    ):
9277        self.egress_filter = egress_filter if egress_filter is not None else ''
9278        '''
9279         A filter applied to the routing logic to pin datasource to nodes.
9280        '''
9281        self.healthy = healthy if healthy is not None else False
9282        '''
9283         True if the datasource is reachable and the credentials are valid.
9284        '''
9285        self.hostname = hostname if hostname is not None else ''
9286        '''
9287
9288        '''
9289        self.id = id if id is not None else ''
9290        '''
9291         Unique identifier of the Resource.
9292        '''
9293        self.name = name if name is not None else ''
9294        '''
9295         Unique human-readable name of the Resource.
9296        '''
9297        self.port = port if port is not None else 0
9298        '''
9299
9300        '''
9301        self.port_override = port_override if port_override is not None else 0
9302        '''
9303
9304        '''
9305        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9306        '''
9307         ID of the secret store containing credentials for this resource, if any.
9308        '''
9309        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9310        '''
9311         Tags is a map of key, value pairs.
9312        '''
9313
9314    def __repr__(self):
9315        return '<sdm.RawTCP ' + \
9316            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9317            'healthy: ' + repr(self.healthy) + ' ' +\
9318            'hostname: ' + repr(self.hostname) + ' ' +\
9319            'id: ' + repr(self.id) + ' ' +\
9320            'name: ' + repr(self.name) + ' ' +\
9321            'port: ' + repr(self.port) + ' ' +\
9322            'port_override: ' + repr(self.port_override) + ' ' +\
9323            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9324            'tags: ' + repr(self.tags) + ' ' +\
9325            '>'
9326
9327    def to_dict(self):
9328        return {
9329            'egress_filter': self.egress_filter,
9330            'healthy': self.healthy,
9331            'hostname': self.hostname,
9332            'id': self.id,
9333            'name': self.name,
9334            'port': self.port,
9335            'port_override': self.port_override,
9336            'secret_store_id': self.secret_store_id,
9337            'tags': self.tags,
9338        }
9339
9340    @classmethod
9341    def from_dict(cls, d):
9342        return cls(
9343            egress_filter=d.get('egress_filter'),
9344            healthy=d.get('healthy'),
9345            hostname=d.get('hostname'),
9346            id=d.get('id'),
9347            name=d.get('name'),
9348            port=d.get('port'),
9349            port_override=d.get('port_override'),
9350            secret_store_id=d.get('secret_store_id'),
9351            tags=d.get('tags'),
9352        )
#   RawTCP( egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
9265    def __init__(
9266        self,
9267        egress_filter=None,
9268        healthy=None,
9269        hostname=None,
9270        id=None,
9271        name=None,
9272        port=None,
9273        port_override=None,
9274        secret_store_id=None,
9275        tags=None,
9276    ):
9277        self.egress_filter = egress_filter if egress_filter is not None else ''
9278        '''
9279         A filter applied to the routing logic to pin datasource to nodes.
9280        '''
9281        self.healthy = healthy if healthy is not None else False
9282        '''
9283         True if the datasource is reachable and the credentials are valid.
9284        '''
9285        self.hostname = hostname if hostname is not None else ''
9286        '''
9287
9288        '''
9289        self.id = id if id is not None else ''
9290        '''
9291         Unique identifier of the Resource.
9292        '''
9293        self.name = name if name is not None else ''
9294        '''
9295         Unique human-readable name of the Resource.
9296        '''
9297        self.port = port if port is not None else 0
9298        '''
9299
9300        '''
9301        self.port_override = port_override if port_override is not None else 0
9302        '''
9303
9304        '''
9305        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9306        '''
9307         ID of the secret store containing credentials for this resource, if any.
9308        '''
9309        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9310        '''
9311         Tags is a map of key, value pairs.
9312        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
9327    def to_dict(self):
9328        return {
9329            'egress_filter': self.egress_filter,
9330            'healthy': self.healthy,
9331            'hostname': self.hostname,
9332            'id': self.id,
9333            'name': self.name,
9334            'port': self.port,
9335            'port_override': self.port_override,
9336            'secret_store_id': self.secret_store_id,
9337            'tags': self.tags,
9338        }
#  
@classmethod
def from_dict(cls, d):
View Source
9340    @classmethod
9341    def from_dict(cls, d):
9342        return cls(
9343            egress_filter=d.get('egress_filter'),
9344            healthy=d.get('healthy'),
9345            hostname=d.get('hostname'),
9346            id=d.get('id'),
9347            name=d.get('name'),
9348            port=d.get('port'),
9349            port_override=d.get('port_override'),
9350            secret_store_id=d.get('secret_store_id'),
9351            tags=d.get('tags'),
9352        )
#   class Redis:
View Source
9355class Redis:
9356    '''
9357
9358    '''
9359    __slots__ = [
9360        'egress_filter',
9361        'healthy',
9362        'hostname',
9363        'id',
9364        'name',
9365        'password',
9366        'port',
9367        'port_override',
9368        'secret_store_id',
9369        'tags',
9370    ]
9371
9372    def __init__(
9373        self,
9374        egress_filter=None,
9375        healthy=None,
9376        hostname=None,
9377        id=None,
9378        name=None,
9379        password=None,
9380        port=None,
9381        port_override=None,
9382        secret_store_id=None,
9383        tags=None,
9384    ):
9385        self.egress_filter = egress_filter if egress_filter is not None else ''
9386        '''
9387         A filter applied to the routing logic to pin datasource to nodes.
9388        '''
9389        self.healthy = healthy if healthy is not None else False
9390        '''
9391         True if the datasource is reachable and the credentials are valid.
9392        '''
9393        self.hostname = hostname if hostname is not None else ''
9394        '''
9395
9396        '''
9397        self.id = id if id is not None else ''
9398        '''
9399         Unique identifier of the Resource.
9400        '''
9401        self.name = name if name is not None else ''
9402        '''
9403         Unique human-readable name of the Resource.
9404        '''
9405        self.password = password if password is not None else ''
9406        '''
9407
9408        '''
9409        self.port = port if port is not None else 0
9410        '''
9411
9412        '''
9413        self.port_override = port_override if port_override is not None else 0
9414        '''
9415
9416        '''
9417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9418        '''
9419         ID of the secret store containing credentials for this resource, if any.
9420        '''
9421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9422        '''
9423         Tags is a map of key, value pairs.
9424        '''
9425
9426    def __repr__(self):
9427        return '<sdm.Redis ' + \
9428            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9429            'healthy: ' + repr(self.healthy) + ' ' +\
9430            'hostname: ' + repr(self.hostname) + ' ' +\
9431            'id: ' + repr(self.id) + ' ' +\
9432            'name: ' + repr(self.name) + ' ' +\
9433            'password: ' + repr(self.password) + ' ' +\
9434            'port: ' + repr(self.port) + ' ' +\
9435            'port_override: ' + repr(self.port_override) + ' ' +\
9436            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9437            'tags: ' + repr(self.tags) + ' ' +\
9438            '>'
9439
9440    def to_dict(self):
9441        return {
9442            'egress_filter': self.egress_filter,
9443            'healthy': self.healthy,
9444            'hostname': self.hostname,
9445            'id': self.id,
9446            'name': self.name,
9447            'password': self.password,
9448            'port': self.port,
9449            'port_override': self.port_override,
9450            'secret_store_id': self.secret_store_id,
9451            'tags': self.tags,
9452        }
9453
9454    @classmethod
9455    def from_dict(cls, d):
9456        return cls(
9457            egress_filter=d.get('egress_filter'),
9458            healthy=d.get('healthy'),
9459            hostname=d.get('hostname'),
9460            id=d.get('id'),
9461            name=d.get('name'),
9462            password=d.get('password'),
9463            port=d.get('port'),
9464            port_override=d.get('port_override'),
9465            secret_store_id=d.get('secret_store_id'),
9466            tags=d.get('tags'),
9467        )
#   Redis( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None )
View Source
9372    def __init__(
9373        self,
9374        egress_filter=None,
9375        healthy=None,
9376        hostname=None,
9377        id=None,
9378        name=None,
9379        password=None,
9380        port=None,
9381        port_override=None,
9382        secret_store_id=None,
9383        tags=None,
9384    ):
9385        self.egress_filter = egress_filter if egress_filter is not None else ''
9386        '''
9387         A filter applied to the routing logic to pin datasource to nodes.
9388        '''
9389        self.healthy = healthy if healthy is not None else False
9390        '''
9391         True if the datasource is reachable and the credentials are valid.
9392        '''
9393        self.hostname = hostname if hostname is not None else ''
9394        '''
9395
9396        '''
9397        self.id = id if id is not None else ''
9398        '''
9399         Unique identifier of the Resource.
9400        '''
9401        self.name = name if name is not None else ''
9402        '''
9403         Unique human-readable name of the Resource.
9404        '''
9405        self.password = password if password is not None else ''
9406        '''
9407
9408        '''
9409        self.port = port if port is not None else 0
9410        '''
9411
9412        '''
9413        self.port_override = port_override if port_override is not None else 0
9414        '''
9415
9416        '''
9417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9418        '''
9419         ID of the secret store containing credentials for this resource, if any.
9420        '''
9421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9422        '''
9423         Tags is a map of key, value pairs.
9424        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
9440    def to_dict(self):
9441        return {
9442            'egress_filter': self.egress_filter,
9443            'healthy': self.healthy,
9444            'hostname': self.hostname,
9445            'id': self.id,
9446            'name': self.name,
9447            'password': self.password,
9448            'port': self.port,
9449            'port_override': self.port_override,
9450            'secret_store_id': self.secret_store_id,
9451            'tags': self.tags,
9452        }
#  
@classmethod
def from_dict(cls, d):
View Source
9454    @classmethod
9455    def from_dict(cls, d):
9456        return cls(
9457            egress_filter=d.get('egress_filter'),
9458            healthy=d.get('healthy'),
9459            hostname=d.get('hostname'),
9460            id=d.get('id'),
9461            name=d.get('name'),
9462            password=d.get('password'),
9463            port=d.get('port'),
9464            port_override=d.get('port_override'),
9465            secret_store_id=d.get('secret_store_id'),
9466            tags=d.get('tags'),
9467        )
#   class Redshift:
View Source
9470class Redshift:
9471    '''
9472
9473    '''
9474    __slots__ = [
9475        'database',
9476        'egress_filter',
9477        'healthy',
9478        'hostname',
9479        'id',
9480        'name',
9481        'override_database',
9482        'password',
9483        'port',
9484        'port_override',
9485        'secret_store_id',
9486        'tags',
9487        'username',
9488    ]
9489
9490    def __init__(
9491        self,
9492        database=None,
9493        egress_filter=None,
9494        healthy=None,
9495        hostname=None,
9496        id=None,
9497        name=None,
9498        override_database=None,
9499        password=None,
9500        port=None,
9501        port_override=None,
9502        secret_store_id=None,
9503        tags=None,
9504        username=None,
9505    ):
9506        self.database = database if database is not None else ''
9507        '''
9508
9509        '''
9510        self.egress_filter = egress_filter if egress_filter is not None else ''
9511        '''
9512         A filter applied to the routing logic to pin datasource to nodes.
9513        '''
9514        self.healthy = healthy if healthy is not None else False
9515        '''
9516         True if the datasource is reachable and the credentials are valid.
9517        '''
9518        self.hostname = hostname if hostname is not None else ''
9519        '''
9520
9521        '''
9522        self.id = id if id is not None else ''
9523        '''
9524         Unique identifier of the Resource.
9525        '''
9526        self.name = name if name is not None else ''
9527        '''
9528         Unique human-readable name of the Resource.
9529        '''
9530        self.override_database = override_database if override_database is not None else False
9531        '''
9532
9533        '''
9534        self.password = password if password is not None else ''
9535        '''
9536
9537        '''
9538        self.port = port if port is not None else 0
9539        '''
9540
9541        '''
9542        self.port_override = port_override if port_override is not None else 0
9543        '''
9544
9545        '''
9546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9547        '''
9548         ID of the secret store containing credentials for this resource, if any.
9549        '''
9550        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9551        '''
9552         Tags is a map of key, value pairs.
9553        '''
9554        self.username = username if username is not None else ''
9555        '''
9556
9557        '''
9558
9559    def __repr__(self):
9560        return '<sdm.Redshift ' + \
9561            'database: ' + repr(self.database) + ' ' +\
9562            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9563            'healthy: ' + repr(self.healthy) + ' ' +\
9564            'hostname: ' + repr(self.hostname) + ' ' +\
9565            'id: ' + repr(self.id) + ' ' +\
9566            'name: ' + repr(self.name) + ' ' +\
9567            'override_database: ' + repr(self.override_database) + ' ' +\
9568            'password: ' + repr(self.password) + ' ' +\
9569            'port: ' + repr(self.port) + ' ' +\
9570            'port_override: ' + repr(self.port_override) + ' ' +\
9571            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9572            'tags: ' + repr(self.tags) + ' ' +\
9573            'username: ' + repr(self.username) + ' ' +\
9574            '>'
9575
9576    def to_dict(self):
9577        return {
9578            'database': self.database,
9579            'egress_filter': self.egress_filter,
9580            'healthy': self.healthy,
9581            'hostname': self.hostname,
9582            'id': self.id,
9583            'name': self.name,
9584            'override_database': self.override_database,
9585            'password': self.password,
9586            'port': self.port,
9587            'port_override': self.port_override,
9588            'secret_store_id': self.secret_store_id,
9589            'tags': self.tags,
9590            'username': self.username,
9591        }
9592
9593    @classmethod
9594    def from_dict(cls, d):
9595        return cls(
9596            database=d.get('database'),
9597            egress_filter=d.get('egress_filter'),
9598            healthy=d.get('healthy'),
9599            hostname=d.get('hostname'),
9600            id=d.get('id'),
9601            name=d.get('name'),
9602            override_database=d.get('override_database'),
9603            password=d.get('password'),
9604            port=d.get('port'),
9605            port_override=d.get('port_override'),
9606            secret_store_id=d.get('secret_store_id'),
9607            tags=d.get('tags'),
9608            username=d.get('username'),
9609        )
#   Redshift( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
9490    def __init__(
9491        self,
9492        database=None,
9493        egress_filter=None,
9494        healthy=None,
9495        hostname=None,
9496        id=None,
9497        name=None,
9498        override_database=None,
9499        password=None,
9500        port=None,
9501        port_override=None,
9502        secret_store_id=None,
9503        tags=None,
9504        username=None,
9505    ):
9506        self.database = database if database is not None else ''
9507        '''
9508
9509        '''
9510        self.egress_filter = egress_filter if egress_filter is not None else ''
9511        '''
9512         A filter applied to the routing logic to pin datasource to nodes.
9513        '''
9514        self.healthy = healthy if healthy is not None else False
9515        '''
9516         True if the datasource is reachable and the credentials are valid.
9517        '''
9518        self.hostname = hostname if hostname is not None else ''
9519        '''
9520
9521        '''
9522        self.id = id if id is not None else ''
9523        '''
9524         Unique identifier of the Resource.
9525        '''
9526        self.name = name if name is not None else ''
9527        '''
9528         Unique human-readable name of the Resource.
9529        '''
9530        self.override_database = override_database if override_database is not None else False
9531        '''
9532
9533        '''
9534        self.password = password if password is not None else ''
9535        '''
9536
9537        '''
9538        self.port = port if port is not None else 0
9539        '''
9540
9541        '''
9542        self.port_override = port_override if port_override is not None else 0
9543        '''
9544
9545        '''
9546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9547        '''
9548         ID of the secret store containing credentials for this resource, if any.
9549        '''
9550        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9551        '''
9552         Tags is a map of key, value pairs.
9553        '''
9554        self.username = username if username is not None else ''
9555        '''
9556
9557        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
9576    def to_dict(self):
9577        return {
9578            'database': self.database,
9579            'egress_filter': self.egress_filter,
9580            'healthy': self.healthy,
9581            'hostname': self.hostname,
9582            'id': self.id,
9583            'name': self.name,
9584            'override_database': self.override_database,
9585            'password': self.password,
9586            'port': self.port,
9587            'port_override': self.port_override,
9588            'secret_store_id': self.secret_store_id,
9589            'tags': self.tags,
9590            'username': self.username,
9591        }
#  
@classmethod
def from_dict(cls, d):
View Source
9593    @classmethod
9594    def from_dict(cls, d):
9595        return cls(
9596            database=d.get('database'),
9597            egress_filter=d.get('egress_filter'),
9598            healthy=d.get('healthy'),
9599            hostname=d.get('hostname'),
9600            id=d.get('id'),
9601            name=d.get('name'),
9602            override_database=d.get('override_database'),
9603            password=d.get('password'),
9604            port=d.get('port'),
9605            port_override=d.get('port_override'),
9606            secret_store_id=d.get('secret_store_id'),
9607            tags=d.get('tags'),
9608            username=d.get('username'),
9609        )
#   class Relay:
View Source
9612class Relay:
9613    '''
9614     Relay represents a StrongDM CLI installation running in relay mode.
9615    '''
9616    __slots__ = [
9617        'gateway_filter',
9618        'id',
9619        'name',
9620        'state',
9621        'tags',
9622    ]
9623
9624    def __init__(
9625        self,
9626        gateway_filter=None,
9627        id=None,
9628        name=None,
9629        state=None,
9630        tags=None,
9631    ):
9632        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9633        '''
9634         GatewayFilter can be used to restrict the peering between relays and
9635         gateways.
9636        '''
9637        self.id = id if id is not None else ''
9638        '''
9639         Unique identifier of the Relay.
9640        '''
9641        self.name = name if name is not None else ''
9642        '''
9643         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9644        '''
9645        self.state = state if state is not None else ''
9646        '''
9647         The current state of the relay. One of: "new", "verifying_restart",
9648         "awaiting_restart", "restarting", "started", "stopped", "dead",
9649         "unknown".
9650        '''
9651        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9652        '''
9653         Tags is a map of key, value pairs.
9654        '''
9655
9656    def __repr__(self):
9657        return '<sdm.Relay ' + \
9658            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9659            'id: ' + repr(self.id) + ' ' +\
9660            'name: ' + repr(self.name) + ' ' +\
9661            'state: ' + repr(self.state) + ' ' +\
9662            'tags: ' + repr(self.tags) + ' ' +\
9663            '>'
9664
9665    def to_dict(self):
9666        return {
9667            'gateway_filter': self.gateway_filter,
9668            'id': self.id,
9669            'name': self.name,
9670            'state': self.state,
9671            'tags': self.tags,
9672        }
9673
9674    @classmethod
9675    def from_dict(cls, d):
9676        return cls(
9677            gateway_filter=d.get('gateway_filter'),
9678            id=d.get('id'),
9679            name=d.get('name'),
9680            state=d.get('state'),
9681            tags=d.get('tags'),
9682        )

Relay represents a StrongDM CLI installation running in relay mode.

#   Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
View Source
9624    def __init__(
9625        self,
9626        gateway_filter=None,
9627        id=None,
9628        name=None,
9629        state=None,
9630        tags=None,
9631    ):
9632        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9633        '''
9634         GatewayFilter can be used to restrict the peering between relays and
9635         gateways.
9636        '''
9637        self.id = id if id is not None else ''
9638        '''
9639         Unique identifier of the Relay.
9640        '''
9641        self.name = name if name is not None else ''
9642        '''
9643         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9644        '''
9645        self.state = state if state is not None else ''
9646        '''
9647         The current state of the relay. One of: "new", "verifying_restart",
9648         "awaiting_restart", "restarting", "started", "stopped", "dead",
9649         "unknown".
9650        '''
9651        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9652        '''
9653         Tags is a map of key, value pairs.
9654        '''
#   gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

#   id

Unique identifier of the Relay.

#   name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

#   state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
9665    def to_dict(self):
9666        return {
9667            'gateway_filter': self.gateway_filter,
9668            'id': self.id,
9669            'name': self.name,
9670            'state': self.state,
9671            'tags': self.tags,
9672        }
#  
@classmethod
def from_dict(cls, d):
View Source
9674    @classmethod
9675    def from_dict(cls, d):
9676        return cls(
9677            gateway_filter=d.get('gateway_filter'),
9678            id=d.get('id'),
9679            name=d.get('name'),
9680            state=d.get('state'),
9681            tags=d.get('tags'),
9682        )
#   class ResourceCreateResponse:
View Source
9685class ResourceCreateResponse:
9686    '''
9687     ResourceCreateResponse reports how the Resources were created in the system.
9688    '''
9689    __slots__ = [
9690        'meta',
9691        'rate_limit',
9692        'resource',
9693    ]
9694
9695    def __init__(
9696        self,
9697        meta=None,
9698        rate_limit=None,
9699        resource=None,
9700    ):
9701        self.meta = meta if meta is not None else None
9702        '''
9703         Reserved for future use.
9704        '''
9705        self.rate_limit = rate_limit if rate_limit is not None else None
9706        '''
9707         Rate limit information.
9708        '''
9709        self.resource = resource if resource is not None else None
9710        '''
9711         The created Resource.
9712        '''
9713
9714    def __repr__(self):
9715        return '<sdm.ResourceCreateResponse ' + \
9716            'meta: ' + repr(self.meta) + ' ' +\
9717            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9718            'resource: ' + repr(self.resource) + ' ' +\
9719            '>'
9720
9721    def to_dict(self):
9722        return {
9723            'meta': self.meta,
9724            'rate_limit': self.rate_limit,
9725            'resource': self.resource,
9726        }
9727
9728    @classmethod
9729    def from_dict(cls, d):
9730        return cls(
9731            meta=d.get('meta'),
9732            rate_limit=d.get('rate_limit'),
9733            resource=d.get('resource'),
9734        )

ResourceCreateResponse reports how the Resources were created in the system.

#   ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
View Source
9695    def __init__(
9696        self,
9697        meta=None,
9698        rate_limit=None,
9699        resource=None,
9700    ):
9701        self.meta = meta if meta is not None else None
9702        '''
9703         Reserved for future use.
9704        '''
9705        self.rate_limit = rate_limit if rate_limit is not None else None
9706        '''
9707         Rate limit information.
9708        '''
9709        self.resource = resource if resource is not None else None
9710        '''
9711         The created Resource.
9712        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   resource

The created Resource.

#   def to_dict(self):
View Source
9721    def to_dict(self):
9722        return {
9723            'meta': self.meta,
9724            'rate_limit': self.rate_limit,
9725            'resource': self.resource,
9726        }
#  
@classmethod
def from_dict(cls, d):
View Source
9728    @classmethod
9729    def from_dict(cls, d):
9730        return cls(
9731            meta=d.get('meta'),
9732            rate_limit=d.get('rate_limit'),
9733            resource=d.get('resource'),
9734        )
#   class ResourceDeleteResponse:
View Source
9737class ResourceDeleteResponse:
9738    '''
9739     ResourceDeleteResponse returns information about a Resource that was deleted.
9740    '''
9741    __slots__ = [
9742        'meta',
9743        'rate_limit',
9744    ]
9745
9746    def __init__(
9747        self,
9748        meta=None,
9749        rate_limit=None,
9750    ):
9751        self.meta = meta if meta is not None else None
9752        '''
9753         Reserved for future use.
9754        '''
9755        self.rate_limit = rate_limit if rate_limit is not None else None
9756        '''
9757         Rate limit information.
9758        '''
9759
9760    def __repr__(self):
9761        return '<sdm.ResourceDeleteResponse ' + \
9762            'meta: ' + repr(self.meta) + ' ' +\
9763            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9764            '>'
9765
9766    def to_dict(self):
9767        return {
9768            'meta': self.meta,
9769            'rate_limit': self.rate_limit,
9770        }
9771
9772    @classmethod
9773    def from_dict(cls, d):
9774        return cls(
9775            meta=d.get('meta'),
9776            rate_limit=d.get('rate_limit'),
9777        )

ResourceDeleteResponse returns information about a Resource that was deleted.

#   ResourceDeleteResponse(meta=None, rate_limit=None)
View Source
9746    def __init__(
9747        self,
9748        meta=None,
9749        rate_limit=None,
9750    ):
9751        self.meta = meta if meta is not None else None
9752        '''
9753         Reserved for future use.
9754        '''
9755        self.rate_limit = rate_limit if rate_limit is not None else None
9756        '''
9757         Rate limit information.
9758        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
9766    def to_dict(self):
9767        return {
9768            'meta': self.meta,
9769            'rate_limit': self.rate_limit,
9770        }
#  
@classmethod
def from_dict(cls, d):
View Source
9772    @classmethod
9773    def from_dict(cls, d):
9774        return cls(
9775            meta=d.get('meta'),
9776            rate_limit=d.get('rate_limit'),
9777        )
#   class ResourceGetResponse:
View Source
9780class ResourceGetResponse:
9781    '''
9782     ResourceGetResponse returns a requested Resource.
9783    '''
9784    __slots__ = [
9785        'meta',
9786        'rate_limit',
9787        'resource',
9788    ]
9789
9790    def __init__(
9791        self,
9792        meta=None,
9793        rate_limit=None,
9794        resource=None,
9795    ):
9796        self.meta = meta if meta is not None else None
9797        '''
9798         Reserved for future use.
9799        '''
9800        self.rate_limit = rate_limit if rate_limit is not None else None
9801        '''
9802         Rate limit information.
9803        '''
9804        self.resource = resource if resource is not None else None
9805        '''
9806         The requested Resource.
9807        '''
9808
9809    def __repr__(self):
9810        return '<sdm.ResourceGetResponse ' + \
9811            'meta: ' + repr(self.meta) + ' ' +\
9812            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9813            'resource: ' + repr(self.resource) + ' ' +\
9814            '>'
9815
9816    def to_dict(self):
9817        return {
9818            'meta': self.meta,
9819            'rate_limit': self.rate_limit,
9820            'resource': self.resource,
9821        }
9822
9823    @classmethod
9824    def from_dict(cls, d):
9825        return cls(
9826            meta=d.get('meta'),
9827            rate_limit=d.get('rate_limit'),
9828            resource=d.get('resource'),
9829        )

ResourceGetResponse returns a requested Resource.

#   ResourceGetResponse(meta=None, rate_limit=None, resource=None)
View Source
9790    def __init__(
9791        self,
9792        meta=None,
9793        rate_limit=None,
9794        resource=None,
9795    ):
9796        self.meta = meta if meta is not None else None
9797        '''
9798         Reserved for future use.
9799        '''
9800        self.rate_limit = rate_limit if rate_limit is not None else None
9801        '''
9802         Rate limit information.
9803        '''
9804        self.resource = resource if resource is not None else None
9805        '''
9806         The requested Resource.
9807        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   resource

The requested Resource.

#   def to_dict(self):
View Source
9816    def to_dict(self):
9817        return {
9818            'meta': self.meta,
9819            'rate_limit': self.rate_limit,
9820            'resource': self.resource,
9821        }
#  
@classmethod
def from_dict(cls, d):
View Source
9823    @classmethod
9824    def from_dict(cls, d):
9825        return cls(
9826            meta=d.get('meta'),
9827            rate_limit=d.get('rate_limit'),
9828            resource=d.get('resource'),
9829        )
#   class ResourceUpdateResponse:
View Source
9832class ResourceUpdateResponse:
9833    '''
9834     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
9835     a ResourceUpdateRequest.
9836    '''
9837    __slots__ = [
9838        'meta',
9839        'rate_limit',
9840        'resource',
9841    ]
9842
9843    def __init__(
9844        self,
9845        meta=None,
9846        rate_limit=None,
9847        resource=None,
9848    ):
9849        self.meta = meta if meta is not None else None
9850        '''
9851         Reserved for future use.
9852        '''
9853        self.rate_limit = rate_limit if rate_limit is not None else None
9854        '''
9855         Rate limit information.
9856        '''
9857        self.resource = resource if resource is not None else None
9858        '''
9859         The updated Resource.
9860        '''
9861
9862    def __repr__(self):
9863        return '<sdm.ResourceUpdateResponse ' + \
9864            'meta: ' + repr(self.meta) + ' ' +\
9865            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9866            'resource: ' + repr(self.resource) + ' ' +\
9867            '>'
9868
9869    def to_dict(self):
9870        return {
9871            'meta': self.meta,
9872            'rate_limit': self.rate_limit,
9873            'resource': self.resource,
9874        }
9875
9876    @classmethod
9877    def from_dict(cls, d):
9878        return cls(
9879            meta=d.get('meta'),
9880            rate_limit=d.get('rate_limit'),
9881            resource=d.get('resource'),
9882        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

#   ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
View Source
9843    def __init__(
9844        self,
9845        meta=None,
9846        rate_limit=None,
9847        resource=None,
9848    ):
9849        self.meta = meta if meta is not None else None
9850        '''
9851         Reserved for future use.
9852        '''
9853        self.rate_limit = rate_limit if rate_limit is not None else None
9854        '''
9855         Rate limit information.
9856        '''
9857        self.resource = resource if resource is not None else None
9858        '''
9859         The updated Resource.
9860        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   resource

The updated Resource.

#   def to_dict(self):
View Source
9869    def to_dict(self):
9870        return {
9871            'meta': self.meta,
9872            'rate_limit': self.rate_limit,
9873            'resource': self.resource,
9874        }
#  
@classmethod
def from_dict(cls, d):
View Source
9876    @classmethod
9877    def from_dict(cls, d):
9878        return cls(
9879            meta=d.get('meta'),
9880            rate_limit=d.get('rate_limit'),
9881            resource=d.get('resource'),
9882        )
#   class Role:
View Source
9885class Role:
9886    '''
9887     A Role has a list of access rules which determine which Resources the members
9888     of the Role have access to. An Account can be a member of multiple Roles via
9889     AccountAttachments.
9890    '''
9891    __slots__ = [
9892        'access_rules',
9893        'composite',
9894        'id',
9895        'name',
9896        'tags',
9897    ]
9898
9899    def __init__(
9900        self,
9901        access_rules=None,
9902        composite=None,
9903        id=None,
9904        name=None,
9905        tags=None,
9906    ):
9907        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
9908        )
9909        '''
9910         AccessRules is a list of access rules defining the resources this Role has access to.
9911        '''
9912        self.composite = composite if composite is not None else False
9913        '''
9914         Composite is true if the Role is a composite role.
9915         
9916         Deprecated: composite roles are deprecated, use multi-role via
9917         AccountAttachments instead.
9918        '''
9919        self.id = id if id is not None else ''
9920        '''
9921         Unique identifier of the Role.
9922        '''
9923        self.name = name if name is not None else ''
9924        '''
9925         Unique human-readable name of the Role.
9926        '''
9927        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9928        '''
9929         Tags is a map of key, value pairs.
9930        '''
9931
9932    def __repr__(self):
9933        return '<sdm.Role ' + \
9934            'access_rules: ' + repr(self.access_rules) + ' ' +\
9935            'composite: ' + repr(self.composite) + ' ' +\
9936            'id: ' + repr(self.id) + ' ' +\
9937            'name: ' + repr(self.name) + ' ' +\
9938            'tags: ' + repr(self.tags) + ' ' +\
9939            '>'
9940
9941    def to_dict(self):
9942        return {
9943            'access_rules': self.access_rules,
9944            'composite': self.composite,
9945            'id': self.id,
9946            'name': self.name,
9947            'tags': self.tags,
9948        }
9949
9950    @classmethod
9951    def from_dict(cls, d):
9952        return cls(
9953            access_rules=d.get('access_rules'),
9954            composite=d.get('composite'),
9955            id=d.get('id'),
9956            name=d.get('name'),
9957            tags=d.get('tags'),
9958        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

#   Role(access_rules=None, composite=None, id=None, name=None, tags=None)
View Source
9899    def __init__(
9900        self,
9901        access_rules=None,
9902        composite=None,
9903        id=None,
9904        name=None,
9905        tags=None,
9906    ):
9907        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
9908        )
9909        '''
9910         AccessRules is a list of access rules defining the resources this Role has access to.
9911        '''
9912        self.composite = composite if composite is not None else False
9913        '''
9914         Composite is true if the Role is a composite role.
9915         
9916         Deprecated: composite roles are deprecated, use multi-role via
9917         AccountAttachments instead.
9918        '''
9919        self.id = id if id is not None else ''
9920        '''
9921         Unique identifier of the Role.
9922        '''
9923        self.name = name if name is not None else ''
9924        '''
9925         Unique human-readable name of the Role.
9926        '''
9927        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9928        '''
9929         Tags is a map of key, value pairs.
9930        '''
#   access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

#   composite

Composite is true if the Role is a composite role.

Deprecated: composite roles are deprecated, use multi-role via AccountAttachments instead.

#   id

Unique identifier of the Role.

#   name

Unique human-readable name of the Role.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
9941    def to_dict(self):
9942        return {
9943            'access_rules': self.access_rules,
9944            'composite': self.composite,
9945            'id': self.id,
9946            'name': self.name,
9947            'tags': self.tags,
9948        }
#  
@classmethod
def from_dict(cls, d):
View Source
9950    @classmethod
9951    def from_dict(cls, d):
9952        return cls(
9953            access_rules=d.get('access_rules'),
9954            composite=d.get('composite'),
9955            id=d.get('id'),
9956            name=d.get('name'),
9957            tags=d.get('tags'),
9958        )
#   class RoleAttachment:
View Source
 9961class RoleAttachment:
 9962    '''
 9963     A RoleAttachment assigns a role to a composite role.
 9964     
 9965     Deprecated: use multi-role via AccountAttachments instead.
 9966    '''
 9967    __slots__ = [
 9968        'attached_role_id',
 9969        'composite_role_id',
 9970        'id',
 9971    ]
 9972
 9973    def __init__(
 9974        self,
 9975        attached_role_id=None,
 9976        composite_role_id=None,
 9977        id=None,
 9978    ):
 9979        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
 9980        '''
 9981         The id of the attached role of this RoleAttachment.
 9982        '''
 9983        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
 9984        '''
 9985         The id of the composite role of this RoleAttachment.
 9986        '''
 9987        self.id = id if id is not None else ''
 9988        '''
 9989         Unique identifier of the RoleAttachment.
 9990        '''
 9991
 9992    def __repr__(self):
 9993        return '<sdm.RoleAttachment ' + \
 9994            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
 9995            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
 9996            'id: ' + repr(self.id) + ' ' +\
 9997            '>'
 9998
 9999    def to_dict(self):
10000        return {
10001            'attached_role_id': self.attached_role_id,
10002            'composite_role_id': self.composite_role_id,
10003            'id': self.id,
10004        }
10005
10006    @classmethod
10007    def from_dict(cls, d):
10008        return cls(
10009            attached_role_id=d.get('attached_role_id'),
10010            composite_role_id=d.get('composite_role_id'),
10011            id=d.get('id'),
10012        )

A RoleAttachment assigns a role to a composite role.

Deprecated: use multi-role via AccountAttachments instead.

#   RoleAttachment(attached_role_id=None, composite_role_id=None, id=None)
View Source
9973    def __init__(
9974        self,
9975        attached_role_id=None,
9976        composite_role_id=None,
9977        id=None,
9978    ):
9979        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
9980        '''
9981         The id of the attached role of this RoleAttachment.
9982        '''
9983        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
9984        '''
9985         The id of the composite role of this RoleAttachment.
9986        '''
9987        self.id = id if id is not None else ''
9988        '''
9989         Unique identifier of the RoleAttachment.
9990        '''
#   attached_role_id

The id of the attached role of this RoleAttachment.

#   composite_role_id

The id of the composite role of this RoleAttachment.

#   id

Unique identifier of the RoleAttachment.

#   def to_dict(self):
View Source
 9999    def to_dict(self):
10000        return {
10001            'attached_role_id': self.attached_role_id,
10002            'composite_role_id': self.composite_role_id,
10003            'id': self.id,
10004        }
#  
@classmethod
def from_dict(cls, d):
View Source
10006    @classmethod
10007    def from_dict(cls, d):
10008        return cls(
10009            attached_role_id=d.get('attached_role_id'),
10010            composite_role_id=d.get('composite_role_id'),
10011            id=d.get('id'),
10012        )
#   class RoleAttachmentCreateResponse:
View Source
10015class RoleAttachmentCreateResponse:
10016    '''
10017     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
10018     
10019     Deprecated: use multi-role via AccountAttachments instead.
10020    '''
10021    __slots__ = [
10022        'meta',
10023        'rate_limit',
10024        'role_attachment',
10025    ]
10026
10027    def __init__(
10028        self,
10029        meta=None,
10030        rate_limit=None,
10031        role_attachment=None,
10032    ):
10033        self.meta = meta if meta is not None else None
10034        '''
10035         Reserved for future use.
10036        '''
10037        self.rate_limit = rate_limit if rate_limit is not None else None
10038        '''
10039         Rate limit information.
10040        '''
10041        self.role_attachment = role_attachment if role_attachment is not None else None
10042        '''
10043         The created RoleAttachment.
10044        '''
10045
10046    def __repr__(self):
10047        return '<sdm.RoleAttachmentCreateResponse ' + \
10048            'meta: ' + repr(self.meta) + ' ' +\
10049            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10050            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
10051            '>'
10052
10053    def to_dict(self):
10054        return {
10055            'meta': self.meta,
10056            'rate_limit': self.rate_limit,
10057            'role_attachment': self.role_attachment,
10058        }
10059
10060    @classmethod
10061    def from_dict(cls, d):
10062        return cls(
10063            meta=d.get('meta'),
10064            rate_limit=d.get('rate_limit'),
10065            role_attachment=d.get('role_attachment'),
10066        )

RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.

Deprecated: use multi-role via AccountAttachments instead.

#   RoleAttachmentCreateResponse(meta=None, rate_limit=None, role_attachment=None)
View Source
10027    def __init__(
10028        self,
10029        meta=None,
10030        rate_limit=None,
10031        role_attachment=None,
10032    ):
10033        self.meta = meta if meta is not None else None
10034        '''
10035         Reserved for future use.
10036        '''
10037        self.rate_limit = rate_limit if rate_limit is not None else None
10038        '''
10039         Rate limit information.
10040        '''
10041        self.role_attachment = role_attachment if role_attachment is not None else None
10042        '''
10043         The created RoleAttachment.
10044        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role_attachment

The created RoleAttachment.

#   def to_dict(self):
View Source
10053    def to_dict(self):
10054        return {
10055            'meta': self.meta,
10056            'rate_limit': self.rate_limit,
10057            'role_attachment': self.role_attachment,
10058        }
#  
@classmethod
def from_dict(cls, d):
View Source
10060    @classmethod
10061    def from_dict(cls, d):
10062        return cls(
10063            meta=d.get('meta'),
10064            rate_limit=d.get('rate_limit'),
10065            role_attachment=d.get('role_attachment'),
10066        )
#   class RoleAttachmentDeleteResponse:
View Source
10069class RoleAttachmentDeleteResponse:
10070    '''
10071     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
10072     
10073     Deprecated: use multi-role via AccountAttachments instead.
10074    '''
10075    __slots__ = [
10076        'meta',
10077        'rate_limit',
10078    ]
10079
10080    def __init__(
10081        self,
10082        meta=None,
10083        rate_limit=None,
10084    ):
10085        self.meta = meta if meta is not None else None
10086        '''
10087         Reserved for future use.
10088        '''
10089        self.rate_limit = rate_limit if rate_limit is not None else None
10090        '''
10091         Rate limit information.
10092        '''
10093
10094    def __repr__(self):
10095        return '<sdm.RoleAttachmentDeleteResponse ' + \
10096            'meta: ' + repr(self.meta) + ' ' +\
10097            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10098            '>'
10099
10100    def to_dict(self):
10101        return {
10102            'meta': self.meta,
10103            'rate_limit': self.rate_limit,
10104        }
10105
10106    @classmethod
10107    def from_dict(cls, d):
10108        return cls(
10109            meta=d.get('meta'),
10110            rate_limit=d.get('rate_limit'),
10111        )

RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.

Deprecated: use multi-role via AccountAttachments instead.

#   RoleAttachmentDeleteResponse(meta=None, rate_limit=None)
View Source
10080    def __init__(
10081        self,
10082        meta=None,
10083        rate_limit=None,
10084    ):
10085        self.meta = meta if meta is not None else None
10086        '''
10087         Reserved for future use.
10088        '''
10089        self.rate_limit = rate_limit if rate_limit is not None else None
10090        '''
10091         Rate limit information.
10092        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
10100    def to_dict(self):
10101        return {
10102            'meta': self.meta,
10103            'rate_limit': self.rate_limit,
10104        }
#  
@classmethod
def from_dict(cls, d):
View Source
10106    @classmethod
10107    def from_dict(cls, d):
10108        return cls(
10109            meta=d.get('meta'),
10110            rate_limit=d.get('rate_limit'),
10111        )
#   class RoleAttachmentGetResponse:
View Source
10114class RoleAttachmentGetResponse:
10115    '''
10116     RoleAttachmentGetResponse returns a requested RoleAttachment.
10117     
10118     Deprecated: use multi-role via AccountAttachments instead.
10119    '''
10120    __slots__ = [
10121        'meta',
10122        'rate_limit',
10123        'role_attachment',
10124    ]
10125
10126    def __init__(
10127        self,
10128        meta=None,
10129        rate_limit=None,
10130        role_attachment=None,
10131    ):
10132        self.meta = meta if meta is not None else None
10133        '''
10134         Reserved for future use.
10135        '''
10136        self.rate_limit = rate_limit if rate_limit is not None else None
10137        '''
10138         Rate limit information.
10139        '''
10140        self.role_attachment = role_attachment if role_attachment is not None else None
10141        '''
10142         The requested RoleAttachment.
10143        '''
10144
10145    def __repr__(self):
10146        return '<sdm.RoleAttachmentGetResponse ' + \
10147            'meta: ' + repr(self.meta) + ' ' +\
10148            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10149            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
10150            '>'
10151
10152    def to_dict(self):
10153        return {
10154            'meta': self.meta,
10155            'rate_limit': self.rate_limit,
10156            'role_attachment': self.role_attachment,
10157        }
10158
10159    @classmethod
10160    def from_dict(cls, d):
10161        return cls(
10162            meta=d.get('meta'),
10163            rate_limit=d.get('rate_limit'),
10164            role_attachment=d.get('role_attachment'),
10165        )

RoleAttachmentGetResponse returns a requested RoleAttachment.

Deprecated: use multi-role via AccountAttachments instead.

#   RoleAttachmentGetResponse(meta=None, rate_limit=None, role_attachment=None)
View Source
10126    def __init__(
10127        self,
10128        meta=None,
10129        rate_limit=None,
10130        role_attachment=None,
10131    ):
10132        self.meta = meta if meta is not None else None
10133        '''
10134         Reserved for future use.
10135        '''
10136        self.rate_limit = rate_limit if rate_limit is not None else None
10137        '''
10138         Rate limit information.
10139        '''
10140        self.role_attachment = role_attachment if role_attachment is not None else None
10141        '''
10142         The requested RoleAttachment.
10143        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role_attachment

The requested RoleAttachment.

#   def to_dict(self):
View Source
10152    def to_dict(self):
10153        return {
10154            'meta': self.meta,
10155            'rate_limit': self.rate_limit,
10156            'role_attachment': self.role_attachment,
10157        }
#  
@classmethod
def from_dict(cls, d):
View Source
10159    @classmethod
10160    def from_dict(cls, d):
10161        return cls(
10162            meta=d.get('meta'),
10163            rate_limit=d.get('rate_limit'),
10164            role_attachment=d.get('role_attachment'),
10165        )
#   class RoleCreateResponse:
View Source
10168class RoleCreateResponse:
10169    '''
10170     RoleCreateResponse reports how the Roles were created in the system. It can
10171     communicate partial successes or failures.
10172    '''
10173    __slots__ = [
10174        'meta',
10175        'rate_limit',
10176        'role',
10177    ]
10178
10179    def __init__(
10180        self,
10181        meta=None,
10182        rate_limit=None,
10183        role=None,
10184    ):
10185        self.meta = meta if meta is not None else None
10186        '''
10187         Reserved for future use.
10188        '''
10189        self.rate_limit = rate_limit if rate_limit is not None else None
10190        '''
10191         Rate limit information.
10192        '''
10193        self.role = role if role is not None else None
10194        '''
10195         The created Role.
10196        '''
10197
10198    def __repr__(self):
10199        return '<sdm.RoleCreateResponse ' + \
10200            'meta: ' + repr(self.meta) + ' ' +\
10201            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10202            'role: ' + repr(self.role) + ' ' +\
10203            '>'
10204
10205    def to_dict(self):
10206        return {
10207            'meta': self.meta,
10208            'rate_limit': self.rate_limit,
10209            'role': self.role,
10210        }
10211
10212    @classmethod
10213    def from_dict(cls, d):
10214        return cls(
10215            meta=d.get('meta'),
10216            rate_limit=d.get('rate_limit'),
10217            role=d.get('role'),
10218        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

#   RoleCreateResponse(meta=None, rate_limit=None, role=None)
View Source
10179    def __init__(
10180        self,
10181        meta=None,
10182        rate_limit=None,
10183        role=None,
10184    ):
10185        self.meta = meta if meta is not None else None
10186        '''
10187         Reserved for future use.
10188        '''
10189        self.rate_limit = rate_limit if rate_limit is not None else None
10190        '''
10191         Rate limit information.
10192        '''
10193        self.role = role if role is not None else None
10194        '''
10195         The created Role.
10196        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role

The created Role.

#   def to_dict(self):
View Source
10205    def to_dict(self):
10206        return {
10207            'meta': self.meta,
10208            'rate_limit': self.rate_limit,
10209            'role': self.role,
10210        }
#  
@classmethod
def from_dict(cls, d):
View Source
10212    @classmethod
10213    def from_dict(cls, d):
10214        return cls(
10215            meta=d.get('meta'),
10216            rate_limit=d.get('rate_limit'),
10217            role=d.get('role'),
10218        )
#   class RoleDeleteResponse:
View Source
10221class RoleDeleteResponse:
10222    '''
10223     RoleDeleteResponse returns information about a Role that was deleted.
10224    '''
10225    __slots__ = [
10226        'meta',
10227        'rate_limit',
10228    ]
10229
10230    def __init__(
10231        self,
10232        meta=None,
10233        rate_limit=None,
10234    ):
10235        self.meta = meta if meta is not None else None
10236        '''
10237         Reserved for future use.
10238        '''
10239        self.rate_limit = rate_limit if rate_limit is not None else None
10240        '''
10241         Rate limit information.
10242        '''
10243
10244    def __repr__(self):
10245        return '<sdm.RoleDeleteResponse ' + \
10246            'meta: ' + repr(self.meta) + ' ' +\
10247            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10248            '>'
10249
10250    def to_dict(self):
10251        return {
10252            'meta': self.meta,
10253            'rate_limit': self.rate_limit,
10254        }
10255
10256    @classmethod
10257    def from_dict(cls, d):
10258        return cls(
10259            meta=d.get('meta'),
10260            rate_limit=d.get('rate_limit'),
10261        )

RoleDeleteResponse returns information about a Role that was deleted.

#   RoleDeleteResponse(meta=None, rate_limit=None)
View Source
10230    def __init__(
10231        self,
10232        meta=None,
10233        rate_limit=None,
10234    ):
10235        self.meta = meta if meta is not None else None
10236        '''
10237         Reserved for future use.
10238        '''
10239        self.rate_limit = rate_limit if rate_limit is not None else None
10240        '''
10241         Rate limit information.
10242        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
10250    def to_dict(self):
10251        return {
10252            'meta': self.meta,
10253            'rate_limit': self.rate_limit,
10254        }
#  
@classmethod
def from_dict(cls, d):
View Source
10256    @classmethod
10257    def from_dict(cls, d):
10258        return cls(
10259            meta=d.get('meta'),
10260            rate_limit=d.get('rate_limit'),
10261        )
#   class RoleGetResponse:
View Source
10264class RoleGetResponse:
10265    '''
10266     RoleGetResponse returns a requested Role.
10267    '''
10268    __slots__ = [
10269        'meta',
10270        'rate_limit',
10271        'role',
10272    ]
10273
10274    def __init__(
10275        self,
10276        meta=None,
10277        rate_limit=None,
10278        role=None,
10279    ):
10280        self.meta = meta if meta is not None else None
10281        '''
10282         Reserved for future use.
10283        '''
10284        self.rate_limit = rate_limit if rate_limit is not None else None
10285        '''
10286         Rate limit information.
10287        '''
10288        self.role = role if role is not None else None
10289        '''
10290         The requested Role.
10291        '''
10292
10293    def __repr__(self):
10294        return '<sdm.RoleGetResponse ' + \
10295            'meta: ' + repr(self.meta) + ' ' +\
10296            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10297            'role: ' + repr(self.role) + ' ' +\
10298            '>'
10299
10300    def to_dict(self):
10301        return {
10302            'meta': self.meta,
10303            'rate_limit': self.rate_limit,
10304            'role': self.role,
10305        }
10306
10307    @classmethod
10308    def from_dict(cls, d):
10309        return cls(
10310            meta=d.get('meta'),
10311            rate_limit=d.get('rate_limit'),
10312            role=d.get('role'),
10313        )

RoleGetResponse returns a requested Role.

#   RoleGetResponse(meta=None, rate_limit=None, role=None)
View Source
10274    def __init__(
10275        self,
10276        meta=None,
10277        rate_limit=None,
10278        role=None,
10279    ):
10280        self.meta = meta if meta is not None else None
10281        '''
10282         Reserved for future use.
10283        '''
10284        self.rate_limit = rate_limit if rate_limit is not None else None
10285        '''
10286         Rate limit information.
10287        '''
10288        self.role = role if role is not None else None
10289        '''
10290         The requested Role.
10291        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role

The requested Role.

#   def to_dict(self):
View Source
10300    def to_dict(self):
10301        return {
10302            'meta': self.meta,
10303            'rate_limit': self.rate_limit,
10304            'role': self.role,
10305        }
#  
@classmethod
def from_dict(cls, d):
View Source
10307    @classmethod
10308    def from_dict(cls, d):
10309        return cls(
10310            meta=d.get('meta'),
10311            rate_limit=d.get('rate_limit'),
10312            role=d.get('role'),
10313        )
#   class RoleGrant:
View Source
10316class RoleGrant:
10317    '''
10318     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
10319     
10320     Deprecated: use Role access rules instead.
10321    '''
10322    __slots__ = [
10323        'id',
10324        'resource_id',
10325        'role_id',
10326    ]
10327
10328    def __init__(
10329        self,
10330        id=None,
10331        resource_id=None,
10332        role_id=None,
10333    ):
10334        self.id = id if id is not None else ''
10335        '''
10336         Unique identifier of the RoleGrant.
10337        '''
10338        self.resource_id = resource_id if resource_id is not None else ''
10339        '''
10340         The id of the resource of this RoleGrant.
10341        '''
10342        self.role_id = role_id if role_id is not None else ''
10343        '''
10344         The id of the attached role of this RoleGrant.
10345        '''
10346
10347    def __repr__(self):
10348        return '<sdm.RoleGrant ' + \
10349            'id: ' + repr(self.id) + ' ' +\
10350            'resource_id: ' + repr(self.resource_id) + ' ' +\
10351            'role_id: ' + repr(self.role_id) + ' ' +\
10352            '>'
10353
10354    def to_dict(self):
10355        return {
10356            'id': self.id,
10357            'resource_id': self.resource_id,
10358            'role_id': self.role_id,
10359        }
10360
10361    @classmethod
10362    def from_dict(cls, d):
10363        return cls(
10364            id=d.get('id'),
10365            resource_id=d.get('resource_id'),
10366            role_id=d.get('role_id'),
10367        )

A RoleGrant connects a resource to a role, granting members of the role access to that resource.

Deprecated: use Role access rules instead.

#   RoleGrant(id=None, resource_id=None, role_id=None)
View Source
10328    def __init__(
10329        self,
10330        id=None,
10331        resource_id=None,
10332        role_id=None,
10333    ):
10334        self.id = id if id is not None else ''
10335        '''
10336         Unique identifier of the RoleGrant.
10337        '''
10338        self.resource_id = resource_id if resource_id is not None else ''
10339        '''
10340         The id of the resource of this RoleGrant.
10341        '''
10342        self.role_id = role_id if role_id is not None else ''
10343        '''
10344         The id of the attached role of this RoleGrant.
10345        '''
#   id

Unique identifier of the RoleGrant.

#   resource_id

The id of the resource of this RoleGrant.

#   role_id

The id of the attached role of this RoleGrant.

#   def to_dict(self):
View Source
10354    def to_dict(self):
10355        return {
10356            'id': self.id,
10357            'resource_id': self.resource_id,
10358            'role_id': self.role_id,
10359        }
#  
@classmethod
def from_dict(cls, d):
View Source
10361    @classmethod
10362    def from_dict(cls, d):
10363        return cls(
10364            id=d.get('id'),
10365            resource_id=d.get('resource_id'),
10366            role_id=d.get('role_id'),
10367        )
#   class RoleGrantCreateResponse:
View Source
10370class RoleGrantCreateResponse:
10371    '''
10372     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
10373     
10374     Deprecated: use Role access rules instead.
10375    '''
10376    __slots__ = [
10377        'meta',
10378        'rate_limit',
10379        'role_grant',
10380    ]
10381
10382    def __init__(
10383        self,
10384        meta=None,
10385        rate_limit=None,
10386        role_grant=None,
10387    ):
10388        self.meta = meta if meta is not None else None
10389        '''
10390         Reserved for future use.
10391        '''
10392        self.rate_limit = rate_limit if rate_limit is not None else None
10393        '''
10394         Rate limit information.
10395        '''
10396        self.role_grant = role_grant if role_grant is not None else None
10397        '''
10398         The created RoleGrant.
10399        '''
10400
10401    def __repr__(self):
10402        return '<sdm.RoleGrantCreateResponse ' + \
10403            'meta: ' + repr(self.meta) + ' ' +\
10404            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10405            'role_grant: ' + repr(self.role_grant) + ' ' +\
10406            '>'
10407
10408    def to_dict(self):
10409        return {
10410            'meta': self.meta,
10411            'rate_limit': self.rate_limit,
10412            'role_grant': self.role_grant,
10413        }
10414
10415    @classmethod
10416    def from_dict(cls, d):
10417        return cls(
10418            meta=d.get('meta'),
10419            rate_limit=d.get('rate_limit'),
10420            role_grant=d.get('role_grant'),
10421        )

RoleGrantCreateResponse reports how the RoleGrants were created in the system.

Deprecated: use Role access rules instead.

#   RoleGrantCreateResponse(meta=None, rate_limit=None, role_grant=None)
View Source
10382    def __init__(
10383        self,
10384        meta=None,
10385        rate_limit=None,
10386        role_grant=None,
10387    ):
10388        self.meta = meta if meta is not None else None
10389        '''
10390         Reserved for future use.
10391        '''
10392        self.rate_limit = rate_limit if rate_limit is not None else None
10393        '''
10394         Rate limit information.
10395        '''
10396        self.role_grant = role_grant if role_grant is not None else None
10397        '''
10398         The created RoleGrant.
10399        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role_grant

The created RoleGrant.

#   def to_dict(self):
View Source
10408    def to_dict(self):
10409        return {
10410            'meta': self.meta,
10411            'rate_limit': self.rate_limit,
10412            'role_grant': self.role_grant,
10413        }
#  
@classmethod
def from_dict(cls, d):
View Source
10415    @classmethod
10416    def from_dict(cls, d):
10417        return cls(
10418            meta=d.get('meta'),
10419            rate_limit=d.get('rate_limit'),
10420            role_grant=d.get('role_grant'),
10421        )
#   class RoleGrantDeleteResponse:
View Source
10424class RoleGrantDeleteResponse:
10425    '''
10426     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
10427     
10428     Deprecated: use Role access rules instead.
10429    '''
10430    __slots__ = [
10431        'meta',
10432        'rate_limit',
10433    ]
10434
10435    def __init__(
10436        self,
10437        meta=None,
10438        rate_limit=None,
10439    ):
10440        self.meta = meta if meta is not None else None
10441        '''
10442         Reserved for future use.
10443        '''
10444        self.rate_limit = rate_limit if rate_limit is not None else None
10445        '''
10446         Rate limit information.
10447        '''
10448
10449    def __repr__(self):
10450        return '<sdm.RoleGrantDeleteResponse ' + \
10451            'meta: ' + repr(self.meta) + ' ' +\
10452            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10453            '>'
10454
10455    def to_dict(self):
10456        return {
10457            'meta': self.meta,
10458            'rate_limit': self.rate_limit,
10459        }
10460
10461    @classmethod
10462    def from_dict(cls, d):
10463        return cls(
10464            meta=d.get('meta'),
10465            rate_limit=d.get('rate_limit'),
10466        )

RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.

Deprecated: use Role access rules instead.

#   RoleGrantDeleteResponse(meta=None, rate_limit=None)
View Source
10435    def __init__(
10436        self,
10437        meta=None,
10438        rate_limit=None,
10439    ):
10440        self.meta = meta if meta is not None else None
10441        '''
10442         Reserved for future use.
10443        '''
10444        self.rate_limit = rate_limit if rate_limit is not None else None
10445        '''
10446         Rate limit information.
10447        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
10455    def to_dict(self):
10456        return {
10457            'meta': self.meta,
10458            'rate_limit': self.rate_limit,
10459        }
#  
@classmethod
def from_dict(cls, d):
View Source
10461    @classmethod
10462    def from_dict(cls, d):
10463        return cls(
10464            meta=d.get('meta'),
10465            rate_limit=d.get('rate_limit'),
10466        )
#   class RoleGrantGetResponse:
View Source
10469class RoleGrantGetResponse:
10470    '''
10471     RoleGrantGetResponse returns a requested RoleGrant.
10472     
10473     Deprecated: use Role access rules instead.
10474    '''
10475    __slots__ = [
10476        'meta',
10477        'rate_limit',
10478        'role_grant',
10479    ]
10480
10481    def __init__(
10482        self,
10483        meta=None,
10484        rate_limit=None,
10485        role_grant=None,
10486    ):
10487        self.meta = meta if meta is not None else None
10488        '''
10489         Reserved for future use.
10490        '''
10491        self.rate_limit = rate_limit if rate_limit is not None else None
10492        '''
10493         Rate limit information.
10494        '''
10495        self.role_grant = role_grant if role_grant is not None else None
10496        '''
10497         The requested RoleGrant.
10498        '''
10499
10500    def __repr__(self):
10501        return '<sdm.RoleGrantGetResponse ' + \
10502            'meta: ' + repr(self.meta) + ' ' +\
10503            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10504            'role_grant: ' + repr(self.role_grant) + ' ' +\
10505            '>'
10506
10507    def to_dict(self):
10508        return {
10509            'meta': self.meta,
10510            'rate_limit': self.rate_limit,
10511            'role_grant': self.role_grant,
10512        }
10513
10514    @classmethod
10515    def from_dict(cls, d):
10516        return cls(
10517            meta=d.get('meta'),
10518            rate_limit=d.get('rate_limit'),
10519            role_grant=d.get('role_grant'),
10520        )

RoleGrantGetResponse returns a requested RoleGrant.

Deprecated: use Role access rules instead.

#   RoleGrantGetResponse(meta=None, rate_limit=None, role_grant=None)
View Source
10481    def __init__(
10482        self,
10483        meta=None,
10484        rate_limit=None,
10485        role_grant=None,
10486    ):
10487        self.meta = meta if meta is not None else None
10488        '''
10489         Reserved for future use.
10490        '''
10491        self.rate_limit = rate_limit if rate_limit is not None else None
10492        '''
10493         Rate limit information.
10494        '''
10495        self.role_grant = role_grant if role_grant is not None else None
10496        '''
10497         The requested RoleGrant.
10498        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role_grant

The requested RoleGrant.

#   def to_dict(self):
View Source
10507    def to_dict(self):
10508        return {
10509            'meta': self.meta,
10510            'rate_limit': self.rate_limit,
10511            'role_grant': self.role_grant,
10512        }
#  
@classmethod
def from_dict(cls, d):
View Source
10514    @classmethod
10515    def from_dict(cls, d):
10516        return cls(
10517            meta=d.get('meta'),
10518            rate_limit=d.get('rate_limit'),
10519            role_grant=d.get('role_grant'),
10520        )
#   class RoleUpdateResponse:
View Source
10523class RoleUpdateResponse:
10524    '''
10525     RoleUpdateResponse returns the fields of a Role after it has been updated by
10526     a RoleUpdateRequest.
10527    '''
10528    __slots__ = [
10529        'meta',
10530        'rate_limit',
10531        'role',
10532    ]
10533
10534    def __init__(
10535        self,
10536        meta=None,
10537        rate_limit=None,
10538        role=None,
10539    ):
10540        self.meta = meta if meta is not None else None
10541        '''
10542         Reserved for future use.
10543        '''
10544        self.rate_limit = rate_limit if rate_limit is not None else None
10545        '''
10546         Rate limit information.
10547        '''
10548        self.role = role if role is not None else None
10549        '''
10550         The updated Role.
10551        '''
10552
10553    def __repr__(self):
10554        return '<sdm.RoleUpdateResponse ' + \
10555            'meta: ' + repr(self.meta) + ' ' +\
10556            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10557            'role: ' + repr(self.role) + ' ' +\
10558            '>'
10559
10560    def to_dict(self):
10561        return {
10562            'meta': self.meta,
10563            'rate_limit': self.rate_limit,
10564            'role': self.role,
10565        }
10566
10567    @classmethod
10568    def from_dict(cls, d):
10569        return cls(
10570            meta=d.get('meta'),
10571            rate_limit=d.get('rate_limit'),
10572            role=d.get('role'),
10573        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

#   RoleUpdateResponse(meta=None, rate_limit=None, role=None)
View Source
10534    def __init__(
10535        self,
10536        meta=None,
10537        rate_limit=None,
10538        role=None,
10539    ):
10540        self.meta = meta if meta is not None else None
10541        '''
10542         Reserved for future use.
10543        '''
10544        self.rate_limit = rate_limit if rate_limit is not None else None
10545        '''
10546         Rate limit information.
10547        '''
10548        self.role = role if role is not None else None
10549        '''
10550         The updated Role.
10551        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   role

The updated Role.

#   def to_dict(self):
View Source
10560    def to_dict(self):
10561        return {
10562            'meta': self.meta,
10563            'rate_limit': self.rate_limit,
10564            'role': self.role,
10565        }
#  
@classmethod
def from_dict(cls, d):
View Source
10567    @classmethod
10568    def from_dict(cls, d):
10569        return cls(
10570            meta=d.get('meta'),
10571            rate_limit=d.get('rate_limit'),
10572            role=d.get('role'),
10573        )
#   class SQLServer:
View Source
10576class SQLServer:
10577    '''
10578
10579    '''
10580    __slots__ = [
10581        'database',
10582        'egress_filter',
10583        'healthy',
10584        'hostname',
10585        'id',
10586        'name',
10587        'override_database',
10588        'password',
10589        'port',
10590        'port_override',
10591        'schema',
10592        'secret_store_id',
10593        'tags',
10594        'username',
10595    ]
10596
10597    def __init__(
10598        self,
10599        database=None,
10600        egress_filter=None,
10601        healthy=None,
10602        hostname=None,
10603        id=None,
10604        name=None,
10605        override_database=None,
10606        password=None,
10607        port=None,
10608        port_override=None,
10609        schema=None,
10610        secret_store_id=None,
10611        tags=None,
10612        username=None,
10613    ):
10614        self.database = database if database is not None else ''
10615        '''
10616
10617        '''
10618        self.egress_filter = egress_filter if egress_filter is not None else ''
10619        '''
10620         A filter applied to the routing logic to pin datasource to nodes.
10621        '''
10622        self.healthy = healthy if healthy is not None else False
10623        '''
10624         True if the datasource is reachable and the credentials are valid.
10625        '''
10626        self.hostname = hostname if hostname is not None else ''
10627        '''
10628
10629        '''
10630        self.id = id if id is not None else ''
10631        '''
10632         Unique identifier of the Resource.
10633        '''
10634        self.name = name if name is not None else ''
10635        '''
10636         Unique human-readable name of the Resource.
10637        '''
10638        self.override_database = override_database if override_database is not None else False
10639        '''
10640
10641        '''
10642        self.password = password if password is not None else ''
10643        '''
10644
10645        '''
10646        self.port = port if port is not None else 0
10647        '''
10648
10649        '''
10650        self.port_override = port_override if port_override is not None else 0
10651        '''
10652
10653        '''
10654        self.schema = schema if schema is not None else ''
10655        '''
10656
10657        '''
10658        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10659        '''
10660         ID of the secret store containing credentials for this resource, if any.
10661        '''
10662        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10663        '''
10664         Tags is a map of key, value pairs.
10665        '''
10666        self.username = username if username is not None else ''
10667        '''
10668
10669        '''
10670
10671    def __repr__(self):
10672        return '<sdm.SQLServer ' + \
10673            'database: ' + repr(self.database) + ' ' +\
10674            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10675            'healthy: ' + repr(self.healthy) + ' ' +\
10676            'hostname: ' + repr(self.hostname) + ' ' +\
10677            'id: ' + repr(self.id) + ' ' +\
10678            'name: ' + repr(self.name) + ' ' +\
10679            'override_database: ' + repr(self.override_database) + ' ' +\
10680            'password: ' + repr(self.password) + ' ' +\
10681            'port: ' + repr(self.port) + ' ' +\
10682            'port_override: ' + repr(self.port_override) + ' ' +\
10683            'schema: ' + repr(self.schema) + ' ' +\
10684            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10685            'tags: ' + repr(self.tags) + ' ' +\
10686            'username: ' + repr(self.username) + ' ' +\
10687            '>'
10688
10689    def to_dict(self):
10690        return {
10691            'database': self.database,
10692            'egress_filter': self.egress_filter,
10693            'healthy': self.healthy,
10694            'hostname': self.hostname,
10695            'id': self.id,
10696            'name': self.name,
10697            'override_database': self.override_database,
10698            'password': self.password,
10699            'port': self.port,
10700            'port_override': self.port_override,
10701            'schema': self.schema,
10702            'secret_store_id': self.secret_store_id,
10703            'tags': self.tags,
10704            'username': self.username,
10705        }
10706
10707    @classmethod
10708    def from_dict(cls, d):
10709        return cls(
10710            database=d.get('database'),
10711            egress_filter=d.get('egress_filter'),
10712            healthy=d.get('healthy'),
10713            hostname=d.get('hostname'),
10714            id=d.get('id'),
10715            name=d.get('name'),
10716            override_database=d.get('override_database'),
10717            password=d.get('password'),
10718            port=d.get('port'),
10719            port_override=d.get('port_override'),
10720            schema=d.get('schema'),
10721            secret_store_id=d.get('secret_store_id'),
10722            tags=d.get('tags'),
10723            username=d.get('username'),
10724        )
#   SQLServer( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None )
View Source
10597    def __init__(
10598        self,
10599        database=None,
10600        egress_filter=None,
10601        healthy=None,
10602        hostname=None,
10603        id=None,
10604        name=None,
10605        override_database=None,
10606        password=None,
10607        port=None,
10608        port_override=None,
10609        schema=None,
10610        secret_store_id=None,
10611        tags=None,
10612        username=None,
10613    ):
10614        self.database = database if database is not None else ''
10615        '''
10616
10617        '''
10618        self.egress_filter = egress_filter if egress_filter is not None else ''
10619        '''
10620         A filter applied to the routing logic to pin datasource to nodes.
10621        '''
10622        self.healthy = healthy if healthy is not None else False
10623        '''
10624         True if the datasource is reachable and the credentials are valid.
10625        '''
10626        self.hostname = hostname if hostname is not None else ''
10627        '''
10628
10629        '''
10630        self.id = id if id is not None else ''
10631        '''
10632         Unique identifier of the Resource.
10633        '''
10634        self.name = name if name is not None else ''
10635        '''
10636         Unique human-readable name of the Resource.
10637        '''
10638        self.override_database = override_database if override_database is not None else False
10639        '''
10640
10641        '''
10642        self.password = password if password is not None else ''
10643        '''
10644
10645        '''
10646        self.port = port if port is not None else 0
10647        '''
10648
10649        '''
10650        self.port_override = port_override if port_override is not None else 0
10651        '''
10652
10653        '''
10654        self.schema = schema if schema is not None else ''
10655        '''
10656
10657        '''
10658        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10659        '''
10660         ID of the secret store containing credentials for this resource, if any.
10661        '''
10662        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10663        '''
10664         Tags is a map of key, value pairs.
10665        '''
10666        self.username = username if username is not None else ''
10667        '''
10668
10669        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   override_database
#   password
#   port
#   port_override
#   schema
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
10689    def to_dict(self):
10690        return {
10691            'database': self.database,
10692            'egress_filter': self.egress_filter,
10693            'healthy': self.healthy,
10694            'hostname': self.hostname,
10695            'id': self.id,
10696            'name': self.name,
10697            'override_database': self.override_database,
10698            'password': self.password,
10699            'port': self.port,
10700            'port_override': self.port_override,
10701            'schema': self.schema,
10702            'secret_store_id': self.secret_store_id,
10703            'tags': self.tags,
10704            'username': self.username,
10705        }
#  
@classmethod
def from_dict(cls, d):
View Source
10707    @classmethod
10708    def from_dict(cls, d):
10709        return cls(
10710            database=d.get('database'),
10711            egress_filter=d.get('egress_filter'),
10712            healthy=d.get('healthy'),
10713            hostname=d.get('hostname'),
10714            id=d.get('id'),
10715            name=d.get('name'),
10716            override_database=d.get('override_database'),
10717            password=d.get('password'),
10718            port=d.get('port'),
10719            port_override=d.get('port_override'),
10720            schema=d.get('schema'),
10721            secret_store_id=d.get('secret_store_id'),
10722            tags=d.get('tags'),
10723            username=d.get('username'),
10724        )
#   class SSH:
View Source
10727class SSH:
10728    '''
10729
10730    '''
10731    __slots__ = [
10732        'allow_deprecated_key_exchanges',
10733        'egress_filter',
10734        'healthy',
10735        'hostname',
10736        'id',
10737        'name',
10738        'port',
10739        'port_forwarding',
10740        'public_key',
10741        'secret_store_id',
10742        'tags',
10743        'username',
10744    ]
10745
10746    def __init__(
10747        self,
10748        allow_deprecated_key_exchanges=None,
10749        egress_filter=None,
10750        healthy=None,
10751        hostname=None,
10752        id=None,
10753        name=None,
10754        port=None,
10755        port_forwarding=None,
10756        public_key=None,
10757        secret_store_id=None,
10758        tags=None,
10759        username=None,
10760    ):
10761        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10762        '''
10763
10764        '''
10765        self.egress_filter = egress_filter if egress_filter is not None else ''
10766        '''
10767         A filter applied to the routing logic to pin datasource to nodes.
10768        '''
10769        self.healthy = healthy if healthy is not None else False
10770        '''
10771         True if the datasource is reachable and the credentials are valid.
10772        '''
10773        self.hostname = hostname if hostname is not None else ''
10774        '''
10775
10776        '''
10777        self.id = id if id is not None else ''
10778        '''
10779         Unique identifier of the Resource.
10780        '''
10781        self.name = name if name is not None else ''
10782        '''
10783         Unique human-readable name of the Resource.
10784        '''
10785        self.port = port if port is not None else 0
10786        '''
10787
10788        '''
10789        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10790        '''
10791
10792        '''
10793        self.public_key = public_key if public_key is not None else ''
10794        '''
10795
10796        '''
10797        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10798        '''
10799         ID of the secret store containing credentials for this resource, if any.
10800        '''
10801        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10802        '''
10803         Tags is a map of key, value pairs.
10804        '''
10805        self.username = username if username is not None else ''
10806        '''
10807
10808        '''
10809
10810    def __repr__(self):
10811        return '<sdm.SSH ' + \
10812            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10813            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10814            'healthy: ' + repr(self.healthy) + ' ' +\
10815            'hostname: ' + repr(self.hostname) + ' ' +\
10816            'id: ' + repr(self.id) + ' ' +\
10817            'name: ' + repr(self.name) + ' ' +\
10818            'port: ' + repr(self.port) + ' ' +\
10819            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10820            'public_key: ' + repr(self.public_key) + ' ' +\
10821            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10822            'tags: ' + repr(self.tags) + ' ' +\
10823            'username: ' + repr(self.username) + ' ' +\
10824            '>'
10825
10826    def to_dict(self):
10827        return {
10828            'allow_deprecated_key_exchanges':
10829            self.allow_deprecated_key_exchanges,
10830            'egress_filter': self.egress_filter,
10831            'healthy': self.healthy,
10832            'hostname': self.hostname,
10833            'id': self.id,
10834            'name': self.name,
10835            'port': self.port,
10836            'port_forwarding': self.port_forwarding,
10837            'public_key': self.public_key,
10838            'secret_store_id': self.secret_store_id,
10839            'tags': self.tags,
10840            'username': self.username,
10841        }
10842
10843    @classmethod
10844    def from_dict(cls, d):
10845        return cls(
10846            allow_deprecated_key_exchanges=d.get(
10847                'allow_deprecated_key_exchanges'),
10848            egress_filter=d.get('egress_filter'),
10849            healthy=d.get('healthy'),
10850            hostname=d.get('hostname'),
10851            id=d.get('id'),
10852            name=d.get('name'),
10853            port=d.get('port'),
10854            port_forwarding=d.get('port_forwarding'),
10855            public_key=d.get('public_key'),
10856            secret_store_id=d.get('secret_store_id'),
10857            tags=d.get('tags'),
10858            username=d.get('username'),
10859        )
#   SSH( allow_deprecated_key_exchanges=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, public_key=None, secret_store_id=None, tags=None, username=None )
View Source
10746    def __init__(
10747        self,
10748        allow_deprecated_key_exchanges=None,
10749        egress_filter=None,
10750        healthy=None,
10751        hostname=None,
10752        id=None,
10753        name=None,
10754        port=None,
10755        port_forwarding=None,
10756        public_key=None,
10757        secret_store_id=None,
10758        tags=None,
10759        username=None,
10760    ):
10761        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10762        '''
10763
10764        '''
10765        self.egress_filter = egress_filter if egress_filter is not None else ''
10766        '''
10767         A filter applied to the routing logic to pin datasource to nodes.
10768        '''
10769        self.healthy = healthy if healthy is not None else False
10770        '''
10771         True if the datasource is reachable and the credentials are valid.
10772        '''
10773        self.hostname = hostname if hostname is not None else ''
10774        '''
10775
10776        '''
10777        self.id = id if id is not None else ''
10778        '''
10779         Unique identifier of the Resource.
10780        '''
10781        self.name = name if name is not None else ''
10782        '''
10783         Unique human-readable name of the Resource.
10784        '''
10785        self.port = port if port is not None else 0
10786        '''
10787
10788        '''
10789        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10790        '''
10791
10792        '''
10793        self.public_key = public_key if public_key is not None else ''
10794        '''
10795
10796        '''
10797        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10798        '''
10799         ID of the secret store containing credentials for this resource, if any.
10800        '''
10801        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10802        '''
10803         Tags is a map of key, value pairs.
10804        '''
10805        self.username = username if username is not None else ''
10806        '''
10807
10808        '''
#   allow_deprecated_key_exchanges
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_forwarding
#   public_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
10826    def to_dict(self):
10827        return {
10828            'allow_deprecated_key_exchanges':
10829            self.allow_deprecated_key_exchanges,
10830            'egress_filter': self.egress_filter,
10831            'healthy': self.healthy,
10832            'hostname': self.hostname,
10833            'id': self.id,
10834            'name': self.name,
10835            'port': self.port,
10836            'port_forwarding': self.port_forwarding,
10837            'public_key': self.public_key,
10838            'secret_store_id': self.secret_store_id,
10839            'tags': self.tags,
10840            'username': self.username,
10841        }
#  
@classmethod
def from_dict(cls, d):
View Source
10843    @classmethod
10844    def from_dict(cls, d):
10845        return cls(
10846            allow_deprecated_key_exchanges=d.get(
10847                'allow_deprecated_key_exchanges'),
10848            egress_filter=d.get('egress_filter'),
10849            healthy=d.get('healthy'),
10850            hostname=d.get('hostname'),
10851            id=d.get('id'),
10852            name=d.get('name'),
10853            port=d.get('port'),
10854            port_forwarding=d.get('port_forwarding'),
10855            public_key=d.get('public_key'),
10856            secret_store_id=d.get('secret_store_id'),
10857            tags=d.get('tags'),
10858            username=d.get('username'),
10859        )
#   class SSHCert:
View Source
10862class SSHCert:
10863    '''
10864
10865    '''
10866    __slots__ = [
10867        'allow_deprecated_key_exchanges',
10868        'egress_filter',
10869        'healthy',
10870        'hostname',
10871        'id',
10872        'name',
10873        'port',
10874        'port_forwarding',
10875        'secret_store_id',
10876        'tags',
10877        'username',
10878    ]
10879
10880    def __init__(
10881        self,
10882        allow_deprecated_key_exchanges=None,
10883        egress_filter=None,
10884        healthy=None,
10885        hostname=None,
10886        id=None,
10887        name=None,
10888        port=None,
10889        port_forwarding=None,
10890        secret_store_id=None,
10891        tags=None,
10892        username=None,
10893    ):
10894        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10895        '''
10896
10897        '''
10898        self.egress_filter = egress_filter if egress_filter is not None else ''
10899        '''
10900         A filter applied to the routing logic to pin datasource to nodes.
10901        '''
10902        self.healthy = healthy if healthy is not None else False
10903        '''
10904         True if the datasource is reachable and the credentials are valid.
10905        '''
10906        self.hostname = hostname if hostname is not None else ''
10907        '''
10908
10909        '''
10910        self.id = id if id is not None else ''
10911        '''
10912         Unique identifier of the Resource.
10913        '''
10914        self.name = name if name is not None else ''
10915        '''
10916         Unique human-readable name of the Resource.
10917        '''
10918        self.port = port if port is not None else 0
10919        '''
10920
10921        '''
10922        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10923        '''
10924
10925        '''
10926        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10927        '''
10928         ID of the secret store containing credentials for this resource, if any.
10929        '''
10930        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10931        '''
10932         Tags is a map of key, value pairs.
10933        '''
10934        self.username = username if username is not None else ''
10935        '''
10936
10937        '''
10938
10939    def __repr__(self):
10940        return '<sdm.SSHCert ' + \
10941            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10942            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10943            'healthy: ' + repr(self.healthy) + ' ' +\
10944            'hostname: ' + repr(self.hostname) + ' ' +\
10945            'id: ' + repr(self.id) + ' ' +\
10946            'name: ' + repr(self.name) + ' ' +\
10947            'port: ' + repr(self.port) + ' ' +\
10948            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10949            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10950            'tags: ' + repr(self.tags) + ' ' +\
10951            'username: ' + repr(self.username) + ' ' +\
10952            '>'
10953
10954    def to_dict(self):
10955        return {
10956            'allow_deprecated_key_exchanges':
10957            self.allow_deprecated_key_exchanges,
10958            'egress_filter': self.egress_filter,
10959            'healthy': self.healthy,
10960            'hostname': self.hostname,
10961            'id': self.id,
10962            'name': self.name,
10963            'port': self.port,
10964            'port_forwarding': self.port_forwarding,
10965            'secret_store_id': self.secret_store_id,
10966            'tags': self.tags,
10967            'username': self.username,
10968        }
10969
10970    @classmethod
10971    def from_dict(cls, d):
10972        return cls(
10973            allow_deprecated_key_exchanges=d.get(
10974                'allow_deprecated_key_exchanges'),
10975            egress_filter=d.get('egress_filter'),
10976            healthy=d.get('healthy'),
10977            hostname=d.get('hostname'),
10978            id=d.get('id'),
10979            name=d.get('name'),
10980            port=d.get('port'),
10981            port_forwarding=d.get('port_forwarding'),
10982            secret_store_id=d.get('secret_store_id'),
10983            tags=d.get('tags'),
10984            username=d.get('username'),
10985        )
#   SSHCert( allow_deprecated_key_exchanges=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, secret_store_id=None, tags=None, username=None )
View Source
10880    def __init__(
10881        self,
10882        allow_deprecated_key_exchanges=None,
10883        egress_filter=None,
10884        healthy=None,
10885        hostname=None,
10886        id=None,
10887        name=None,
10888        port=None,
10889        port_forwarding=None,
10890        secret_store_id=None,
10891        tags=None,
10892        username=None,
10893    ):
10894        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10895        '''
10896
10897        '''
10898        self.egress_filter = egress_filter if egress_filter is not None else ''
10899        '''
10900         A filter applied to the routing logic to pin datasource to nodes.
10901        '''
10902        self.healthy = healthy if healthy is not None else False
10903        '''
10904         True if the datasource is reachable and the credentials are valid.
10905        '''
10906        self.hostname = hostname if hostname is not None else ''
10907        '''
10908
10909        '''
10910        self.id = id if id is not None else ''
10911        '''
10912         Unique identifier of the Resource.
10913        '''
10914        self.name = name if name is not None else ''
10915        '''
10916         Unique human-readable name of the Resource.
10917        '''
10918        self.port = port if port is not None else 0
10919        '''
10920
10921        '''
10922        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10923        '''
10924
10925        '''
10926        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10927        '''
10928         ID of the secret store containing credentials for this resource, if any.
10929        '''
10930        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10931        '''
10932         Tags is a map of key, value pairs.
10933        '''
10934        self.username = username if username is not None else ''
10935        '''
10936
10937        '''
#   allow_deprecated_key_exchanges
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_forwarding
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
10954    def to_dict(self):
10955        return {
10956            'allow_deprecated_key_exchanges':
10957            self.allow_deprecated_key_exchanges,
10958            'egress_filter': self.egress_filter,
10959            'healthy': self.healthy,
10960            'hostname': self.hostname,
10961            'id': self.id,
10962            'name': self.name,
10963            'port': self.port,
10964            'port_forwarding': self.port_forwarding,
10965            'secret_store_id': self.secret_store_id,
10966            'tags': self.tags,
10967            'username': self.username,
10968        }
#  
@classmethod
def from_dict(cls, d):
View Source
10970    @classmethod
10971    def from_dict(cls, d):
10972        return cls(
10973            allow_deprecated_key_exchanges=d.get(
10974                'allow_deprecated_key_exchanges'),
10975            egress_filter=d.get('egress_filter'),
10976            healthy=d.get('healthy'),
10977            hostname=d.get('hostname'),
10978            id=d.get('id'),
10979            name=d.get('name'),
10980            port=d.get('port'),
10981            port_forwarding=d.get('port_forwarding'),
10982            secret_store_id=d.get('secret_store_id'),
10983            tags=d.get('tags'),
10984            username=d.get('username'),
10985        )
#   class SSHCustomerKey:
View Source
10988class SSHCustomerKey:
10989    '''
10990
10991    '''
10992    __slots__ = [
10993        'allow_deprecated_key_exchanges',
10994        'egress_filter',
10995        'healthy',
10996        'hostname',
10997        'id',
10998        'name',
10999        'port',
11000        'port_forwarding',
11001        'private_key',
11002        'secret_store_id',
11003        'tags',
11004        'username',
11005    ]
11006
11007    def __init__(
11008        self,
11009        allow_deprecated_key_exchanges=None,
11010        egress_filter=None,
11011        healthy=None,
11012        hostname=None,
11013        id=None,
11014        name=None,
11015        port=None,
11016        port_forwarding=None,
11017        private_key=None,
11018        secret_store_id=None,
11019        tags=None,
11020        username=None,
11021    ):
11022        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11023        '''
11024
11025        '''
11026        self.egress_filter = egress_filter if egress_filter is not None else ''
11027        '''
11028         A filter applied to the routing logic to pin datasource to nodes.
11029        '''
11030        self.healthy = healthy if healthy is not None else False
11031        '''
11032         True if the datasource is reachable and the credentials are valid.
11033        '''
11034        self.hostname = hostname if hostname is not None else ''
11035        '''
11036
11037        '''
11038        self.id = id if id is not None else ''
11039        '''
11040         Unique identifier of the Resource.
11041        '''
11042        self.name = name if name is not None else ''
11043        '''
11044         Unique human-readable name of the Resource.
11045        '''
11046        self.port = port if port is not None else 0
11047        '''
11048
11049        '''
11050        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11051        '''
11052
11053        '''
11054        self.private_key = private_key if private_key is not None else ''
11055        '''
11056
11057        '''
11058        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11059        '''
11060         ID of the secret store containing credentials for this resource, if any.
11061        '''
11062        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11063        '''
11064         Tags is a map of key, value pairs.
11065        '''
11066        self.username = username if username is not None else ''
11067        '''
11068
11069        '''
11070
11071    def __repr__(self):
11072        return '<sdm.SSHCustomerKey ' + \
11073            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11074            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11075            'healthy: ' + repr(self.healthy) + ' ' +\
11076            'hostname: ' + repr(self.hostname) + ' ' +\
11077            'id: ' + repr(self.id) + ' ' +\
11078            'name: ' + repr(self.name) + ' ' +\
11079            'port: ' + repr(self.port) + ' ' +\
11080            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11081            'private_key: ' + repr(self.private_key) + ' ' +\
11082            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11083            'tags: ' + repr(self.tags) + ' ' +\
11084            'username: ' + repr(self.username) + ' ' +\
11085            '>'
11086
11087    def to_dict(self):
11088        return {
11089            'allow_deprecated_key_exchanges':
11090            self.allow_deprecated_key_exchanges,
11091            'egress_filter': self.egress_filter,
11092            'healthy': self.healthy,
11093            'hostname': self.hostname,
11094            'id': self.id,
11095            'name': self.name,
11096            'port': self.port,
11097            'port_forwarding': self.port_forwarding,
11098            'private_key': self.private_key,
11099            'secret_store_id': self.secret_store_id,
11100            'tags': self.tags,
11101            'username': self.username,
11102        }
11103
11104    @classmethod
11105    def from_dict(cls, d):
11106        return cls(
11107            allow_deprecated_key_exchanges=d.get(
11108                'allow_deprecated_key_exchanges'),
11109            egress_filter=d.get('egress_filter'),
11110            healthy=d.get('healthy'),
11111            hostname=d.get('hostname'),
11112            id=d.get('id'),
11113            name=d.get('name'),
11114            port=d.get('port'),
11115            port_forwarding=d.get('port_forwarding'),
11116            private_key=d.get('private_key'),
11117            secret_store_id=d.get('secret_store_id'),
11118            tags=d.get('tags'),
11119            username=d.get('username'),
11120        )
#   SSHCustomerKey( allow_deprecated_key_exchanges=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, private_key=None, secret_store_id=None, tags=None, username=None )
View Source
11007    def __init__(
11008        self,
11009        allow_deprecated_key_exchanges=None,
11010        egress_filter=None,
11011        healthy=None,
11012        hostname=None,
11013        id=None,
11014        name=None,
11015        port=None,
11016        port_forwarding=None,
11017        private_key=None,
11018        secret_store_id=None,
11019        tags=None,
11020        username=None,
11021    ):
11022        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11023        '''
11024
11025        '''
11026        self.egress_filter = egress_filter if egress_filter is not None else ''
11027        '''
11028         A filter applied to the routing logic to pin datasource to nodes.
11029        '''
11030        self.healthy = healthy if healthy is not None else False
11031        '''
11032         True if the datasource is reachable and the credentials are valid.
11033        '''
11034        self.hostname = hostname if hostname is not None else ''
11035        '''
11036
11037        '''
11038        self.id = id if id is not None else ''
11039        '''
11040         Unique identifier of the Resource.
11041        '''
11042        self.name = name if name is not None else ''
11043        '''
11044         Unique human-readable name of the Resource.
11045        '''
11046        self.port = port if port is not None else 0
11047        '''
11048
11049        '''
11050        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11051        '''
11052
11053        '''
11054        self.private_key = private_key if private_key is not None else ''
11055        '''
11056
11057        '''
11058        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11059        '''
11060         ID of the secret store containing credentials for this resource, if any.
11061        '''
11062        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11063        '''
11064         Tags is a map of key, value pairs.
11065        '''
11066        self.username = username if username is not None else ''
11067        '''
11068
11069        '''
#   allow_deprecated_key_exchanges
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   port
#   port_forwarding
#   private_key
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
11087    def to_dict(self):
11088        return {
11089            'allow_deprecated_key_exchanges':
11090            self.allow_deprecated_key_exchanges,
11091            'egress_filter': self.egress_filter,
11092            'healthy': self.healthy,
11093            'hostname': self.hostname,
11094            'id': self.id,
11095            'name': self.name,
11096            'port': self.port,
11097            'port_forwarding': self.port_forwarding,
11098            'private_key': self.private_key,
11099            'secret_store_id': self.secret_store_id,
11100            'tags': self.tags,
11101            'username': self.username,
11102        }
#  
@classmethod
def from_dict(cls, d):
View Source
11104    @classmethod
11105    def from_dict(cls, d):
11106        return cls(
11107            allow_deprecated_key_exchanges=d.get(
11108                'allow_deprecated_key_exchanges'),
11109            egress_filter=d.get('egress_filter'),
11110            healthy=d.get('healthy'),
11111            hostname=d.get('hostname'),
11112            id=d.get('id'),
11113            name=d.get('name'),
11114            port=d.get('port'),
11115            port_forwarding=d.get('port_forwarding'),
11116            private_key=d.get('private_key'),
11117            secret_store_id=d.get('secret_store_id'),
11118            tags=d.get('tags'),
11119            username=d.get('username'),
11120        )
#   class SecretStoreCreateResponse:
View Source
11123class SecretStoreCreateResponse:
11124    '''
11125     SecretStoreCreateResponse reports how the SecretStores were created in the system.
11126    '''
11127    __slots__ = [
11128        'meta',
11129        'rate_limit',
11130        'secret_store',
11131    ]
11132
11133    def __init__(
11134        self,
11135        meta=None,
11136        rate_limit=None,
11137        secret_store=None,
11138    ):
11139        self.meta = meta if meta is not None else None
11140        '''
11141         Reserved for future use.
11142        '''
11143        self.rate_limit = rate_limit if rate_limit is not None else None
11144        '''
11145         Rate limit information.
11146        '''
11147        self.secret_store = secret_store if secret_store is not None else None
11148        '''
11149         The created SecretStore.
11150        '''
11151
11152    def __repr__(self):
11153        return '<sdm.SecretStoreCreateResponse ' + \
11154            'meta: ' + repr(self.meta) + ' ' +\
11155            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11156            'secret_store: ' + repr(self.secret_store) + ' ' +\
11157            '>'
11158
11159    def to_dict(self):
11160        return {
11161            'meta': self.meta,
11162            'rate_limit': self.rate_limit,
11163            'secret_store': self.secret_store,
11164        }
11165
11166    @classmethod
11167    def from_dict(cls, d):
11168        return cls(
11169            meta=d.get('meta'),
11170            rate_limit=d.get('rate_limit'),
11171            secret_store=d.get('secret_store'),
11172        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

#   SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
View Source
11133    def __init__(
11134        self,
11135        meta=None,
11136        rate_limit=None,
11137        secret_store=None,
11138    ):
11139        self.meta = meta if meta is not None else None
11140        '''
11141         Reserved for future use.
11142        '''
11143        self.rate_limit = rate_limit if rate_limit is not None else None
11144        '''
11145         Rate limit information.
11146        '''
11147        self.secret_store = secret_store if secret_store is not None else None
11148        '''
11149         The created SecretStore.
11150        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   secret_store

The created SecretStore.

#   def to_dict(self):
View Source
11159    def to_dict(self):
11160        return {
11161            'meta': self.meta,
11162            'rate_limit': self.rate_limit,
11163            'secret_store': self.secret_store,
11164        }
#  
@classmethod
def from_dict(cls, d):
View Source
11166    @classmethod
11167    def from_dict(cls, d):
11168        return cls(
11169            meta=d.get('meta'),
11170            rate_limit=d.get('rate_limit'),
11171            secret_store=d.get('secret_store'),
11172        )
#   class SecretStoreDeleteResponse:
View Source
11175class SecretStoreDeleteResponse:
11176    '''
11177     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11178    '''
11179    __slots__ = [
11180        'meta',
11181        'rate_limit',
11182    ]
11183
11184    def __init__(
11185        self,
11186        meta=None,
11187        rate_limit=None,
11188    ):
11189        self.meta = meta if meta is not None else None
11190        '''
11191         Reserved for future use.
11192        '''
11193        self.rate_limit = rate_limit if rate_limit is not None else None
11194        '''
11195         Rate limit information.
11196        '''
11197
11198    def __repr__(self):
11199        return '<sdm.SecretStoreDeleteResponse ' + \
11200            'meta: ' + repr(self.meta) + ' ' +\
11201            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11202            '>'
11203
11204    def to_dict(self):
11205        return {
11206            'meta': self.meta,
11207            'rate_limit': self.rate_limit,
11208        }
11209
11210    @classmethod
11211    def from_dict(cls, d):
11212        return cls(
11213            meta=d.get('meta'),
11214            rate_limit=d.get('rate_limit'),
11215        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

#   SecretStoreDeleteResponse(meta=None, rate_limit=None)
View Source
11184    def __init__(
11185        self,
11186        meta=None,
11187        rate_limit=None,
11188    ):
11189        self.meta = meta if meta is not None else None
11190        '''
11191         Reserved for future use.
11192        '''
11193        self.rate_limit = rate_limit if rate_limit is not None else None
11194        '''
11195         Rate limit information.
11196        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   def to_dict(self):
View Source
11204    def to_dict(self):
11205        return {
11206            'meta': self.meta,
11207            'rate_limit': self.rate_limit,
11208        }
#  
@classmethod
def from_dict(cls, d):
View Source
11210    @classmethod
11211    def from_dict(cls, d):
11212        return cls(
11213            meta=d.get('meta'),
11214            rate_limit=d.get('rate_limit'),
11215        )
#   class SecretStoreGetResponse:
View Source
11218class SecretStoreGetResponse:
11219    '''
11220     SecretStoreGetResponse returns a requested SecretStore.
11221    '''
11222    __slots__ = [
11223        'meta',
11224        'rate_limit',
11225        'secret_store',
11226    ]
11227
11228    def __init__(
11229        self,
11230        meta=None,
11231        rate_limit=None,
11232        secret_store=None,
11233    ):
11234        self.meta = meta if meta is not None else None
11235        '''
11236         Reserved for future use.
11237        '''
11238        self.rate_limit = rate_limit if rate_limit is not None else None
11239        '''
11240         Rate limit information.
11241        '''
11242        self.secret_store = secret_store if secret_store is not None else None
11243        '''
11244         The requested SecretStore.
11245        '''
11246
11247    def __repr__(self):
11248        return '<sdm.SecretStoreGetResponse ' + \
11249            'meta: ' + repr(self.meta) + ' ' +\
11250            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11251            'secret_store: ' + repr(self.secret_store) + ' ' +\
11252            '>'
11253
11254    def to_dict(self):
11255        return {
11256            'meta': self.meta,
11257            'rate_limit': self.rate_limit,
11258            'secret_store': self.secret_store,
11259        }
11260
11261    @classmethod
11262    def from_dict(cls, d):
11263        return cls(
11264            meta=d.get('meta'),
11265            rate_limit=d.get('rate_limit'),
11266            secret_store=d.get('secret_store'),
11267        )

SecretStoreGetResponse returns a requested SecretStore.

#   SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
View Source
11228    def __init__(
11229        self,
11230        meta=None,
11231        rate_limit=None,
11232        secret_store=None,
11233    ):
11234        self.meta = meta if meta is not None else None
11235        '''
11236         Reserved for future use.
11237        '''
11238        self.rate_limit = rate_limit if rate_limit is not None else None
11239        '''
11240         Rate limit information.
11241        '''
11242        self.secret_store = secret_store if secret_store is not None else None
11243        '''
11244         The requested SecretStore.
11245        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   secret_store

The requested SecretStore.

#   def to_dict(self):
View Source
11254    def to_dict(self):
11255        return {
11256            'meta': self.meta,
11257            'rate_limit': self.rate_limit,
11258            'secret_store': self.secret_store,
11259        }
#  
@classmethod
def from_dict(cls, d):
View Source
11261    @classmethod
11262    def from_dict(cls, d):
11263        return cls(
11264            meta=d.get('meta'),
11265            rate_limit=d.get('rate_limit'),
11266            secret_store=d.get('secret_store'),
11267        )
#   class SecretStoreUpdateResponse:
View Source
11270class SecretStoreUpdateResponse:
11271    '''
11272     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11273     a SecretStoreUpdateRequest.
11274    '''
11275    __slots__ = [
11276        'meta',
11277        'rate_limit',
11278        'secret_store',
11279    ]
11280
11281    def __init__(
11282        self,
11283        meta=None,
11284        rate_limit=None,
11285        secret_store=None,
11286    ):
11287        self.meta = meta if meta is not None else None
11288        '''
11289         Reserved for future use.
11290        '''
11291        self.rate_limit = rate_limit if rate_limit is not None else None
11292        '''
11293         Rate limit information.
11294        '''
11295        self.secret_store = secret_store if secret_store is not None else None
11296        '''
11297         The updated SecretStore.
11298        '''
11299
11300    def __repr__(self):
11301        return '<sdm.SecretStoreUpdateResponse ' + \
11302            'meta: ' + repr(self.meta) + ' ' +\
11303            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11304            'secret_store: ' + repr(self.secret_store) + ' ' +\
11305            '>'
11306
11307    def to_dict(self):
11308        return {
11309            'meta': self.meta,
11310            'rate_limit': self.rate_limit,
11311            'secret_store': self.secret_store,
11312        }
11313
11314    @classmethod
11315    def from_dict(cls, d):
11316        return cls(
11317            meta=d.get('meta'),
11318            rate_limit=d.get('rate_limit'),
11319            secret_store=d.get('secret_store'),
11320        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

#   SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
View Source
11281    def __init__(
11282        self,
11283        meta=None,
11284        rate_limit=None,
11285        secret_store=None,
11286    ):
11287        self.meta = meta if meta is not None else None
11288        '''
11289         Reserved for future use.
11290        '''
11291        self.rate_limit = rate_limit if rate_limit is not None else None
11292        '''
11293         Rate limit information.
11294        '''
11295        self.secret_store = secret_store if secret_store is not None else None
11296        '''
11297         The updated SecretStore.
11298        '''
#   meta

Reserved for future use.

#   rate_limit

Rate limit information.

#   secret_store

The updated SecretStore.

#   def to_dict(self):
View Source
11307    def to_dict(self):
11308        return {
11309            'meta': self.meta,
11310            'rate_limit': self.rate_limit,
11311            'secret_store': self.secret_store,
11312        }
#  
@classmethod
def from_dict(cls, d):
View Source
11314    @classmethod
11315    def from_dict(cls, d):
11316        return cls(
11317            meta=d.get('meta'),
11318            rate_limit=d.get('rate_limit'),
11319            secret_store=d.get('secret_store'),
11320        )
#   class Service:
View Source
11323class Service:
11324    '''
11325     A Service is a service account that can connect to resources they are granted
11326     directly, or granted via roles. Services are typically automated jobs.
11327    '''
11328    __slots__ = [
11329        'id',
11330        'name',
11331        'suspended',
11332        'tags',
11333    ]
11334
11335    def __init__(
11336        self,
11337        id=None,
11338        name=None,
11339        suspended=None,
11340        tags=None,
11341    ):
11342        self.id = id if id is not None else ''
11343        '''
11344         Unique identifier of the Service.
11345        '''
11346        self.name = name if name is not None else ''
11347        '''
11348         Unique human-readable name of the Service.
11349        '''
11350        self.suspended = suspended if suspended is not None else False
11351        '''
11352         The Service's suspended state.
11353        '''
11354        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11355        '''
11356         Tags is a map of key, value pairs.
11357        '''
11358
11359    def __repr__(self):
11360        return '<sdm.Service ' + \
11361            'id: ' + repr(self.id) + ' ' +\
11362            'name: ' + repr(self.name) + ' ' +\
11363            'suspended: ' + repr(self.suspended) + ' ' +\
11364            'tags: ' + repr(self.tags) + ' ' +\
11365            '>'
11366
11367    def to_dict(self):
11368        return {
11369            'id': self.id,
11370            'name': self.name,
11371            'suspended': self.suspended,
11372            'tags': self.tags,
11373        }
11374
11375    @classmethod
11376    def from_dict(cls, d):
11377        return cls(
11378            id=d.get('id'),
11379            name=d.get('name'),
11380            suspended=d.get('suspended'),
11381            tags=d.get('tags'),
11382        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

#   Service(id=None, name=None, suspended=None, tags=None)
View Source
11335    def __init__(
11336        self,
11337        id=None,
11338        name=None,
11339        suspended=None,
11340        tags=None,
11341    ):
11342        self.id = id if id is not None else ''
11343        '''
11344         Unique identifier of the Service.
11345        '''
11346        self.name = name if name is not None else ''
11347        '''
11348         Unique human-readable name of the Service.
11349        '''
11350        self.suspended = suspended if suspended is not None else False
11351        '''
11352         The Service's suspended state.
11353        '''
11354        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11355        '''
11356         Tags is a map of key, value pairs.
11357        '''
#   id

Unique identifier of the Service.

#   name

Unique human-readable name of the Service.

#   suspended

The Service's suspended state.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
11367    def to_dict(self):
11368        return {
11369            'id': self.id,
11370            'name': self.name,
11371            'suspended': self.suspended,
11372            'tags': self.tags,
11373        }
#  
@classmethod
def from_dict(cls, d):
View Source
11375    @classmethod
11376    def from_dict(cls, d):
11377        return cls(
11378            id=d.get('id'),
11379            name=d.get('name'),
11380            suspended=d.get('suspended'),
11381            tags=d.get('tags'),
11382        )
#   class SingleStore:
View Source
11385class SingleStore:
11386    '''
11387
11388    '''
11389    __slots__ = [
11390        'database',
11391        'egress_filter',
11392        'healthy',
11393        'hostname',
11394        'id',
11395        'name',
11396        'password',
11397        'port',
11398        'port_override',
11399        'secret_store_id',
11400        'tags',
11401        'username',
11402    ]
11403
11404    def __init__(
11405        self,
11406        database=None,
11407        egress_filter=None,
11408        healthy=None,
11409        hostname=None,
11410        id=None,
11411        name=None,
11412        password=None,
11413        port=None,
11414        port_override=None,
11415        secret_store_id=None,
11416        tags=None,
11417        username=None,
11418    ):
11419        self.database = database if database is not None else ''
11420        '''
11421
11422        '''
11423        self.egress_filter = egress_filter if egress_filter is not None else ''
11424        '''
11425         A filter applied to the routing logic to pin datasource to nodes.
11426        '''
11427        self.healthy = healthy if healthy is not None else False
11428        '''
11429         True if the datasource is reachable and the credentials are valid.
11430        '''
11431        self.hostname = hostname if hostname is not None else ''
11432        '''
11433
11434        '''
11435        self.id = id if id is not None else ''
11436        '''
11437         Unique identifier of the Resource.
11438        '''
11439        self.name = name if name is not None else ''
11440        '''
11441         Unique human-readable name of the Resource.
11442        '''
11443        self.password = password if password is not None else ''
11444        '''
11445
11446        '''
11447        self.port = port if port is not None else 0
11448        '''
11449
11450        '''
11451        self.port_override = port_override if port_override is not None else 0
11452        '''
11453
11454        '''
11455        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11456        '''
11457         ID of the secret store containing credentials for this resource, if any.
11458        '''
11459        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11460        '''
11461         Tags is a map of key, value pairs.
11462        '''
11463        self.username = username if username is not None else ''
11464        '''
11465
11466        '''
11467
11468    def __repr__(self):
11469        return '<sdm.SingleStore ' + \
11470            'database: ' + repr(self.database) + ' ' +\
11471            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11472            'healthy: ' + repr(self.healthy) + ' ' +\
11473            'hostname: ' + repr(self.hostname) + ' ' +\
11474            'id: ' + repr(self.id) + ' ' +\
11475            'name: ' + repr(self.name) + ' ' +\
11476            'password: ' + repr(self.password) + ' ' +\
11477            'port: ' + repr(self.port) + ' ' +\
11478            'port_override: ' + repr(self.port_override) + ' ' +\
11479            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11480            'tags: ' + repr(self.tags) + ' ' +\
11481            'username: ' + repr(self.username) + ' ' +\
11482            '>'
11483
11484    def to_dict(self):
11485        return {
11486            'database': self.database,
11487            'egress_filter': self.egress_filter,
11488            'healthy': self.healthy,
11489            'hostname': self.hostname,
11490            'id': self.id,
11491            'name': self.name,
11492            'password': self.password,
11493            'port': self.port,
11494            'port_override': self.port_override,
11495            'secret_store_id': self.secret_store_id,
11496            'tags': self.tags,
11497            'username': self.username,
11498        }
11499
11500    @classmethod
11501    def from_dict(cls, d):
11502        return cls(
11503            database=d.get('database'),
11504            egress_filter=d.get('egress_filter'),
11505            healthy=d.get('healthy'),
11506            hostname=d.get('hostname'),
11507            id=d.get('id'),
11508            name=d.get('name'),
11509            password=d.get('password'),
11510            port=d.get('port'),
11511            port_override=d.get('port_override'),
11512            secret_store_id=d.get('secret_store_id'),
11513            tags=d.get('tags'),
11514            username=d.get('username'),
11515        )
#   SingleStore( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
11404    def __init__(
11405        self,
11406        database=None,
11407        egress_filter=None,
11408        healthy=None,
11409        hostname=None,
11410        id=None,
11411        name=None,
11412        password=None,
11413        port=None,
11414        port_override=None,
11415        secret_store_id=None,
11416        tags=None,
11417        username=None,
11418    ):
11419        self.database = database if database is not None else ''
11420        '''
11421
11422        '''
11423        self.egress_filter = egress_filter if egress_filter is not None else ''
11424        '''
11425         A filter applied to the routing logic to pin datasource to nodes.
11426        '''
11427        self.healthy = healthy if healthy is not None else False
11428        '''
11429         True if the datasource is reachable and the credentials are valid.
11430        '''
11431        self.hostname = hostname if hostname is not None else ''
11432        '''
11433
11434        '''
11435        self.id = id if id is not None else ''
11436        '''
11437         Unique identifier of the Resource.
11438        '''
11439        self.name = name if name is not None else ''
11440        '''
11441         Unique human-readable name of the Resource.
11442        '''
11443        self.password = password if password is not None else ''
11444        '''
11445
11446        '''
11447        self.port = port if port is not None else 0
11448        '''
11449
11450        '''
11451        self.port_override = port_override if port_override is not None else 0
11452        '''
11453
11454        '''
11455        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11456        '''
11457         ID of the secret store containing credentials for this resource, if any.
11458        '''
11459        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11460        '''
11461         Tags is a map of key, value pairs.
11462        '''
11463        self.username = username if username is not None else ''
11464        '''
11465
11466        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
11484    def to_dict(self):
11485        return {
11486            'database': self.database,
11487            'egress_filter': self.egress_filter,
11488            'healthy': self.healthy,
11489            'hostname': self.hostname,
11490            'id': self.id,
11491            'name': self.name,
11492            'password': self.password,
11493            'port': self.port,
11494            'port_override': self.port_override,
11495            'secret_store_id': self.secret_store_id,
11496            'tags': self.tags,
11497            'username': self.username,
11498        }
#  
@classmethod
def from_dict(cls, d):
View Source
11500    @classmethod
11501    def from_dict(cls, d):
11502        return cls(
11503            database=d.get('database'),
11504            egress_filter=d.get('egress_filter'),
11505            healthy=d.get('healthy'),
11506            hostname=d.get('hostname'),
11507            id=d.get('id'),
11508            name=d.get('name'),
11509            password=d.get('password'),
11510            port=d.get('port'),
11511            port_override=d.get('port_override'),
11512            secret_store_id=d.get('secret_store_id'),
11513            tags=d.get('tags'),
11514            username=d.get('username'),
11515        )
#   class Snowflake:
View Source
11518class Snowflake:
11519    '''
11520
11521    '''
11522    __slots__ = [
11523        'database',
11524        'egress_filter',
11525        'healthy',
11526        'hostname',
11527        'id',
11528        'name',
11529        'password',
11530        'port_override',
11531        'schema',
11532        'secret_store_id',
11533        'tags',
11534        'username',
11535    ]
11536
11537    def __init__(
11538        self,
11539        database=None,
11540        egress_filter=None,
11541        healthy=None,
11542        hostname=None,
11543        id=None,
11544        name=None,
11545        password=None,
11546        port_override=None,
11547        schema=None,
11548        secret_store_id=None,
11549        tags=None,
11550        username=None,
11551    ):
11552        self.database = database if database is not None else ''
11553        '''
11554
11555        '''
11556        self.egress_filter = egress_filter if egress_filter is not None else ''
11557        '''
11558         A filter applied to the routing logic to pin datasource to nodes.
11559        '''
11560        self.healthy = healthy if healthy is not None else False
11561        '''
11562         True if the datasource is reachable and the credentials are valid.
11563        '''
11564        self.hostname = hostname if hostname is not None else ''
11565        '''
11566
11567        '''
11568        self.id = id if id is not None else ''
11569        '''
11570         Unique identifier of the Resource.
11571        '''
11572        self.name = name if name is not None else ''
11573        '''
11574         Unique human-readable name of the Resource.
11575        '''
11576        self.password = password if password is not None else ''
11577        '''
11578
11579        '''
11580        self.port_override = port_override if port_override is not None else 0
11581        '''
11582
11583        '''
11584        self.schema = schema if schema is not None else ''
11585        '''
11586
11587        '''
11588        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11589        '''
11590         ID of the secret store containing credentials for this resource, if any.
11591        '''
11592        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11593        '''
11594         Tags is a map of key, value pairs.
11595        '''
11596        self.username = username if username is not None else ''
11597        '''
11598
11599        '''
11600
11601    def __repr__(self):
11602        return '<sdm.Snowflake ' + \
11603            'database: ' + repr(self.database) + ' ' +\
11604            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11605            'healthy: ' + repr(self.healthy) + ' ' +\
11606            'hostname: ' + repr(self.hostname) + ' ' +\
11607            'id: ' + repr(self.id) + ' ' +\
11608            'name: ' + repr(self.name) + ' ' +\
11609            'password: ' + repr(self.password) + ' ' +\
11610            'port_override: ' + repr(self.port_override) + ' ' +\
11611            'schema: ' + repr(self.schema) + ' ' +\
11612            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11613            'tags: ' + repr(self.tags) + ' ' +\
11614            'username: ' + repr(self.username) + ' ' +\
11615            '>'
11616
11617    def to_dict(self):
11618        return {
11619            'database': self.database,
11620            'egress_filter': self.egress_filter,
11621            'healthy': self.healthy,
11622            'hostname': self.hostname,
11623            'id': self.id,
11624            'name': self.name,
11625            'password': self.password,
11626            'port_override': self.port_override,
11627            'schema': self.schema,
11628            'secret_store_id': self.secret_store_id,
11629            'tags': self.tags,
11630            'username': self.username,
11631        }
11632
11633    @classmethod
11634    def from_dict(cls, d):
11635        return cls(
11636            database=d.get('database'),
11637            egress_filter=d.get('egress_filter'),
11638            healthy=d.get('healthy'),
11639            hostname=d.get('hostname'),
11640            id=d.get('id'),
11641            name=d.get('name'),
11642            password=d.get('password'),
11643            port_override=d.get('port_override'),
11644            schema=d.get('schema'),
11645            secret_store_id=d.get('secret_store_id'),
11646            tags=d.get('tags'),
11647            username=d.get('username'),
11648        )
#   Snowflake( database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None )
View Source
11537    def __init__(
11538        self,
11539        database=None,
11540        egress_filter=None,
11541        healthy=None,
11542        hostname=None,
11543        id=None,
11544        name=None,
11545        password=None,
11546        port_override=None,
11547        schema=None,
11548        secret_store_id=None,
11549        tags=None,
11550        username=None,
11551    ):
11552        self.database = database if database is not None else ''
11553        '''
11554
11555        '''
11556        self.egress_filter = egress_filter if egress_filter is not None else ''
11557        '''
11558         A filter applied to the routing logic to pin datasource to nodes.
11559        '''
11560        self.healthy = healthy if healthy is not None else False
11561        '''
11562         True if the datasource is reachable and the credentials are valid.
11563        '''
11564        self.hostname = hostname if hostname is not None else ''
11565        '''
11566
11567        '''
11568        self.id = id if id is not None else ''
11569        '''
11570         Unique identifier of the Resource.
11571        '''
11572        self.name = name if name is not None else ''
11573        '''
11574         Unique human-readable name of the Resource.
11575        '''
11576        self.password = password if password is not None else ''
11577        '''
11578
11579        '''
11580        self.port_override = port_override if port_override is not None else 0
11581        '''
11582
11583        '''
11584        self.schema = schema if schema is not None else ''
11585        '''
11586
11587        '''
11588        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11589        '''
11590         ID of the secret store containing credentials for this resource, if any.
11591        '''
11592        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11593        '''
11594         Tags is a map of key, value pairs.
11595        '''
11596        self.username = username if username is not None else ''
11597        '''
11598
11599        '''
#   database
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port_override
#   schema
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
11617    def to_dict(self):
11618        return {
11619            'database': self.database,
11620            'egress_filter': self.egress_filter,
11621            'healthy': self.healthy,
11622            'hostname': self.hostname,
11623            'id': self.id,
11624            'name': self.name,
11625            'password': self.password,
11626            'port_override': self.port_override,
11627            'schema': self.schema,
11628            'secret_store_id': self.secret_store_id,
11629            'tags': self.tags,
11630            'username': self.username,
11631        }
#  
@classmethod
def from_dict(cls, d):
View Source
11633    @classmethod
11634    def from_dict(cls, d):
11635        return cls(
11636            database=d.get('database'),
11637            egress_filter=d.get('egress_filter'),
11638            healthy=d.get('healthy'),
11639            hostname=d.get('hostname'),
11640            id=d.get('id'),
11641            name=d.get('name'),
11642            password=d.get('password'),
11643            port_override=d.get('port_override'),
11644            schema=d.get('schema'),
11645            secret_store_id=d.get('secret_store_id'),
11646            tags=d.get('tags'),
11647            username=d.get('username'),
11648        )
#   class Sybase:
View Source
11651class Sybase:
11652    '''
11653
11654    '''
11655    __slots__ = [
11656        'egress_filter',
11657        'healthy',
11658        'hostname',
11659        'id',
11660        'name',
11661        'password',
11662        'port',
11663        'port_override',
11664        'secret_store_id',
11665        'tags',
11666        'username',
11667    ]
11668
11669    def __init__(
11670        self,
11671        egress_filter=None,
11672        healthy=None,
11673        hostname=None,
11674        id=None,
11675        name=None,
11676        password=None,
11677        port=None,
11678        port_override=None,
11679        secret_store_id=None,
11680        tags=None,
11681        username=None,
11682    ):
11683        self.egress_filter = egress_filter if egress_filter is not None else ''
11684        '''
11685         A filter applied to the routing logic to pin datasource to nodes.
11686        '''
11687        self.healthy = healthy if healthy is not None else False
11688        '''
11689         True if the datasource is reachable and the credentials are valid.
11690        '''
11691        self.hostname = hostname if hostname is not None else ''
11692        '''
11693
11694        '''
11695        self.id = id if id is not None else ''
11696        '''
11697         Unique identifier of the Resource.
11698        '''
11699        self.name = name if name is not None else ''
11700        '''
11701         Unique human-readable name of the Resource.
11702        '''
11703        self.password = password if password is not None else ''
11704        '''
11705
11706        '''
11707        self.port = port if port is not None else 0
11708        '''
11709
11710        '''
11711        self.port_override = port_override if port_override is not None else 0
11712        '''
11713
11714        '''
11715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11716        '''
11717         ID of the secret store containing credentials for this resource, if any.
11718        '''
11719        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11720        '''
11721         Tags is a map of key, value pairs.
11722        '''
11723        self.username = username if username is not None else ''
11724        '''
11725
11726        '''
11727
11728    def __repr__(self):
11729        return '<sdm.Sybase ' + \
11730            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11731            'healthy: ' + repr(self.healthy) + ' ' +\
11732            'hostname: ' + repr(self.hostname) + ' ' +\
11733            'id: ' + repr(self.id) + ' ' +\
11734            'name: ' + repr(self.name) + ' ' +\
11735            'password: ' + repr(self.password) + ' ' +\
11736            'port: ' + repr(self.port) + ' ' +\
11737            'port_override: ' + repr(self.port_override) + ' ' +\
11738            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11739            'tags: ' + repr(self.tags) + ' ' +\
11740            'username: ' + repr(self.username) + ' ' +\
11741            '>'
11742
11743    def to_dict(self):
11744        return {
11745            'egress_filter': self.egress_filter,
11746            'healthy': self.healthy,
11747            'hostname': self.hostname,
11748            'id': self.id,
11749            'name': self.name,
11750            'password': self.password,
11751            'port': self.port,
11752            'port_override': self.port_override,
11753            'secret_store_id': self.secret_store_id,
11754            'tags': self.tags,
11755            'username': self.username,
11756        }
11757
11758    @classmethod
11759    def from_dict(cls, d):
11760        return cls(
11761            egress_filter=d.get('egress_filter'),
11762            healthy=d.get('healthy'),
11763            hostname=d.get('hostname'),
11764            id=d.get('id'),
11765            name=d.get('name'),
11766            password=d.get('password'),
11767            port=d.get('port'),
11768            port_override=d.get('port_override'),
11769            secret_store_id=d.get('secret_store_id'),
11770            tags=d.get('tags'),
11771            username=d.get('username'),
11772        )
#   Sybase( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
11669    def __init__(
11670        self,
11671        egress_filter=None,
11672        healthy=None,
11673        hostname=None,
11674        id=None,
11675        name=None,
11676        password=None,
11677        port=None,
11678        port_override=None,
11679        secret_store_id=None,
11680        tags=None,
11681        username=None,
11682    ):
11683        self.egress_filter = egress_filter if egress_filter is not None else ''
11684        '''
11685         A filter applied to the routing logic to pin datasource to nodes.
11686        '''
11687        self.healthy = healthy if healthy is not None else False
11688        '''
11689         True if the datasource is reachable and the credentials are valid.
11690        '''
11691        self.hostname = hostname if hostname is not None else ''
11692        '''
11693
11694        '''
11695        self.id = id if id is not None else ''
11696        '''
11697         Unique identifier of the Resource.
11698        '''
11699        self.name = name if name is not None else ''
11700        '''
11701         Unique human-readable name of the Resource.
11702        '''
11703        self.password = password if password is not None else ''
11704        '''
11705
11706        '''
11707        self.port = port if port is not None else 0
11708        '''
11709
11710        '''
11711        self.port_override = port_override if port_override is not None else 0
11712        '''
11713
11714        '''
11715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11716        '''
11717         ID of the secret store containing credentials for this resource, if any.
11718        '''
11719        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11720        '''
11721         Tags is a map of key, value pairs.
11722        '''
11723        self.username = username if username is not None else ''
11724        '''
11725
11726        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
11743    def to_dict(self):
11744        return {
11745            'egress_filter': self.egress_filter,
11746            'healthy': self.healthy,
11747            'hostname': self.hostname,
11748            'id': self.id,
11749            'name': self.name,
11750            'password': self.password,
11751            'port': self.port,
11752            'port_override': self.port_override,
11753            'secret_store_id': self.secret_store_id,
11754            'tags': self.tags,
11755            'username': self.username,
11756        }
#  
@classmethod
def from_dict(cls, d):
View Source
11758    @classmethod
11759    def from_dict(cls, d):
11760        return cls(
11761            egress_filter=d.get('egress_filter'),
11762            healthy=d.get('healthy'),
11763            hostname=d.get('hostname'),
11764            id=d.get('id'),
11765            name=d.get('name'),
11766            password=d.get('password'),
11767            port=d.get('port'),
11768            port_override=d.get('port_override'),
11769            secret_store_id=d.get('secret_store_id'),
11770            tags=d.get('tags'),
11771            username=d.get('username'),
11772        )
#   class SybaseIQ:
View Source
11775class SybaseIQ:
11776    '''
11777
11778    '''
11779    __slots__ = [
11780        'egress_filter',
11781        'healthy',
11782        'hostname',
11783        'id',
11784        'name',
11785        'password',
11786        'port',
11787        'port_override',
11788        'secret_store_id',
11789        'tags',
11790        'username',
11791    ]
11792
11793    def __init__(
11794        self,
11795        egress_filter=None,
11796        healthy=None,
11797        hostname=None,
11798        id=None,
11799        name=None,
11800        password=None,
11801        port=None,
11802        port_override=None,
11803        secret_store_id=None,
11804        tags=None,
11805        username=None,
11806    ):
11807        self.egress_filter = egress_filter if egress_filter is not None else ''
11808        '''
11809         A filter applied to the routing logic to pin datasource to nodes.
11810        '''
11811        self.healthy = healthy if healthy is not None else False
11812        '''
11813         True if the datasource is reachable and the credentials are valid.
11814        '''
11815        self.hostname = hostname if hostname is not None else ''
11816        '''
11817
11818        '''
11819        self.id = id if id is not None else ''
11820        '''
11821         Unique identifier of the Resource.
11822        '''
11823        self.name = name if name is not None else ''
11824        '''
11825         Unique human-readable name of the Resource.
11826        '''
11827        self.password = password if password is not None else ''
11828        '''
11829
11830        '''
11831        self.port = port if port is not None else 0
11832        '''
11833
11834        '''
11835        self.port_override = port_override if port_override is not None else 0
11836        '''
11837
11838        '''
11839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11840        '''
11841         ID of the secret store containing credentials for this resource, if any.
11842        '''
11843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11844        '''
11845         Tags is a map of key, value pairs.
11846        '''
11847        self.username = username if username is not None else ''
11848        '''
11849
11850        '''
11851
11852    def __repr__(self):
11853        return '<sdm.SybaseIQ ' + \
11854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11855            'healthy: ' + repr(self.healthy) + ' ' +\
11856            'hostname: ' + repr(self.hostname) + ' ' +\
11857            'id: ' + repr(self.id) + ' ' +\
11858            'name: ' + repr(self.name) + ' ' +\
11859            'password: ' + repr(self.password) + ' ' +\
11860            'port: ' + repr(self.port) + ' ' +\
11861            'port_override: ' + repr(self.port_override) + ' ' +\
11862            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11863            'tags: ' + repr(self.tags) + ' ' +\
11864            'username: ' + repr(self.username) + ' ' +\
11865            '>'
11866
11867    def to_dict(self):
11868        return {
11869            'egress_filter': self.egress_filter,
11870            'healthy': self.healthy,
11871            'hostname': self.hostname,
11872            'id': self.id,
11873            'name': self.name,
11874            'password': self.password,
11875            'port': self.port,
11876            'port_override': self.port_override,
11877            'secret_store_id': self.secret_store_id,
11878            'tags': self.tags,
11879            'username': self.username,
11880        }
11881
11882    @classmethod
11883    def from_dict(cls, d):
11884        return cls(
11885            egress_filter=d.get('egress_filter'),
11886            healthy=d.get('healthy'),
11887            hostname=d.get('hostname'),
11888            id=d.get('id'),
11889            name=d.get('name'),
11890            password=d.get('password'),
11891            port=d.get('port'),
11892            port_override=d.get('port_override'),
11893            secret_store_id=d.get('secret_store_id'),
11894            tags=d.get('tags'),
11895            username=d.get('username'),
11896        )
#   SybaseIQ( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
11793    def __init__(
11794        self,
11795        egress_filter=None,
11796        healthy=None,
11797        hostname=None,
11798        id=None,
11799        name=None,
11800        password=None,
11801        port=None,
11802        port_override=None,
11803        secret_store_id=None,
11804        tags=None,
11805        username=None,
11806    ):
11807        self.egress_filter = egress_filter if egress_filter is not None else ''
11808        '''
11809         A filter applied to the routing logic to pin datasource to nodes.
11810        '''
11811        self.healthy = healthy if healthy is not None else False
11812        '''
11813         True if the datasource is reachable and the credentials are valid.
11814        '''
11815        self.hostname = hostname if hostname is not None else ''
11816        '''
11817
11818        '''
11819        self.id = id if id is not None else ''
11820        '''
11821         Unique identifier of the Resource.
11822        '''
11823        self.name = name if name is not None else ''
11824        '''
11825         Unique human-readable name of the Resource.
11826        '''
11827        self.password = password if password is not None else ''
11828        '''
11829
11830        '''
11831        self.port = port if port is not None else 0
11832        '''
11833
11834        '''
11835        self.port_override = port_override if port_override is not None else 0
11836        '''
11837
11838        '''
11839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11840        '''
11841         ID of the secret store containing credentials for this resource, if any.
11842        '''
11843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11844        '''
11845         Tags is a map of key, value pairs.
11846        '''
11847        self.username = username if username is not None else ''
11848        '''
11849
11850        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
11867    def to_dict(self):
11868        return {
11869            'egress_filter': self.egress_filter,
11870            'healthy': self.healthy,
11871            'hostname': self.hostname,
11872            'id': self.id,
11873            'name': self.name,
11874            'password': self.password,
11875            'port': self.port,
11876            'port_override': self.port_override,
11877            'secret_store_id': self.secret_store_id,
11878            'tags': self.tags,
11879            'username': self.username,
11880        }
#  
@classmethod
def from_dict(cls, d):
View Source
11882    @classmethod
11883    def from_dict(cls, d):
11884        return cls(
11885            egress_filter=d.get('egress_filter'),
11886            healthy=d.get('healthy'),
11887            hostname=d.get('hostname'),
11888            id=d.get('id'),
11889            name=d.get('name'),
11890            password=d.get('password'),
11891            port=d.get('port'),
11892            port_override=d.get('port_override'),
11893            secret_store_id=d.get('secret_store_id'),
11894            tags=d.get('tags'),
11895            username=d.get('username'),
11896        )
#   class Tag:
View Source
11899class Tag:
11900    '''
11901
11902    '''
11903    __slots__ = [
11904        'name',
11905        'value',
11906    ]
11907
11908    def __init__(
11909        self,
11910        name=None,
11911        value=None,
11912    ):
11913        self.name = name if name is not None else ''
11914        '''
11915
11916        '''
11917        self.value = value if value is not None else ''
11918        '''
11919
11920        '''
11921
11922    def __repr__(self):
11923        return '<sdm.Tag ' + \
11924            'name: ' + repr(self.name) + ' ' +\
11925            'value: ' + repr(self.value) + ' ' +\
11926            '>'
11927
11928    def to_dict(self):
11929        return {
11930            'name': self.name,
11931            'value': self.value,
11932        }
11933
11934    @classmethod
11935    def from_dict(cls, d):
11936        return cls(
11937            name=d.get('name'),
11938            value=d.get('value'),
11939        )
#   Tag(name=None, value=None)
View Source
11908    def __init__(
11909        self,
11910        name=None,
11911        value=None,
11912    ):
11913        self.name = name if name is not None else ''
11914        '''
11915
11916        '''
11917        self.value = value if value is not None else ''
11918        '''
11919
11920        '''
#   name
#   value
#   def to_dict(self):
View Source
11928    def to_dict(self):
11929        return {
11930            'name': self.name,
11931            'value': self.value,
11932        }
#  
@classmethod
def from_dict(cls, d):
View Source
11934    @classmethod
11935    def from_dict(cls, d):
11936        return cls(
11937            name=d.get('name'),
11938            value=d.get('value'),
11939        )
#   class Teradata:
View Source
11942class Teradata:
11943    '''
11944
11945    '''
11946    __slots__ = [
11947        'egress_filter',
11948        'healthy',
11949        'hostname',
11950        'id',
11951        'name',
11952        'password',
11953        'port',
11954        'port_override',
11955        'secret_store_id',
11956        'tags',
11957        'username',
11958    ]
11959
11960    def __init__(
11961        self,
11962        egress_filter=None,
11963        healthy=None,
11964        hostname=None,
11965        id=None,
11966        name=None,
11967        password=None,
11968        port=None,
11969        port_override=None,
11970        secret_store_id=None,
11971        tags=None,
11972        username=None,
11973    ):
11974        self.egress_filter = egress_filter if egress_filter is not None else ''
11975        '''
11976         A filter applied to the routing logic to pin datasource to nodes.
11977        '''
11978        self.healthy = healthy if healthy is not None else False
11979        '''
11980         True if the datasource is reachable and the credentials are valid.
11981        '''
11982        self.hostname = hostname if hostname is not None else ''
11983        '''
11984
11985        '''
11986        self.id = id if id is not None else ''
11987        '''
11988         Unique identifier of the Resource.
11989        '''
11990        self.name = name if name is not None else ''
11991        '''
11992         Unique human-readable name of the Resource.
11993        '''
11994        self.password = password if password is not None else ''
11995        '''
11996
11997        '''
11998        self.port = port if port is not None else 0
11999        '''
12000
12001        '''
12002        self.port_override = port_override if port_override is not None else 0
12003        '''
12004
12005        '''
12006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12007        '''
12008         ID of the secret store containing credentials for this resource, if any.
12009        '''
12010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12011        '''
12012         Tags is a map of key, value pairs.
12013        '''
12014        self.username = username if username is not None else ''
12015        '''
12016
12017        '''
12018
12019    def __repr__(self):
12020        return '<sdm.Teradata ' + \
12021            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12022            'healthy: ' + repr(self.healthy) + ' ' +\
12023            'hostname: ' + repr(self.hostname) + ' ' +\
12024            'id: ' + repr(self.id) + ' ' +\
12025            'name: ' + repr(self.name) + ' ' +\
12026            'password: ' + repr(self.password) + ' ' +\
12027            'port: ' + repr(self.port) + ' ' +\
12028            'port_override: ' + repr(self.port_override) + ' ' +\
12029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12030            'tags: ' + repr(self.tags) + ' ' +\
12031            'username: ' + repr(self.username) + ' ' +\
12032            '>'
12033
12034    def to_dict(self):
12035        return {
12036            'egress_filter': self.egress_filter,
12037            'healthy': self.healthy,
12038            'hostname': self.hostname,
12039            'id': self.id,
12040            'name': self.name,
12041            'password': self.password,
12042            'port': self.port,
12043            'port_override': self.port_override,
12044            'secret_store_id': self.secret_store_id,
12045            'tags': self.tags,
12046            'username': self.username,
12047        }
12048
12049    @classmethod
12050    def from_dict(cls, d):
12051        return cls(
12052            egress_filter=d.get('egress_filter'),
12053            healthy=d.get('healthy'),
12054            hostname=d.get('hostname'),
12055            id=d.get('id'),
12056            name=d.get('name'),
12057            password=d.get('password'),
12058            port=d.get('port'),
12059            port_override=d.get('port_override'),
12060            secret_store_id=d.get('secret_store_id'),
12061            tags=d.get('tags'),
12062            username=d.get('username'),
12063        )
#   Teradata( egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None )
View Source
11960    def __init__(
11961        self,
11962        egress_filter=None,
11963        healthy=None,
11964        hostname=None,
11965        id=None,
11966        name=None,
11967        password=None,
11968        port=None,
11969        port_override=None,
11970        secret_store_id=None,
11971        tags=None,
11972        username=None,
11973    ):
11974        self.egress_filter = egress_filter if egress_filter is not None else ''
11975        '''
11976         A filter applied to the routing logic to pin datasource to nodes.
11977        '''
11978        self.healthy = healthy if healthy is not None else False
11979        '''
11980         True if the datasource is reachable and the credentials are valid.
11981        '''
11982        self.hostname = hostname if hostname is not None else ''
11983        '''
11984
11985        '''
11986        self.id = id if id is not None else ''
11987        '''
11988         Unique identifier of the Resource.
11989        '''
11990        self.name = name if name is not None else ''
11991        '''
11992         Unique human-readable name of the Resource.
11993        '''
11994        self.password = password if password is not None else ''
11995        '''
11996
11997        '''
11998        self.port = port if port is not None else 0
11999        '''
12000
12001        '''
12002        self.port_override = port_override if port_override is not None else 0
12003        '''
12004
12005        '''
12006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12007        '''
12008         ID of the secret store containing credentials for this resource, if any.
12009        '''
12010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12011        '''
12012         Tags is a map of key, value pairs.
12013        '''
12014        self.username = username if username is not None else ''
12015        '''
12016
12017        '''
#   egress_filter

A filter applied to the routing logic to pin datasource to nodes.

#   healthy

True if the datasource is reachable and the credentials are valid.

#   hostname
#   id

Unique identifier of the Resource.

#   name

Unique human-readable name of the Resource.

#   password
#   port
#   port_override
#   secret_store_id

ID of the secret store containing credentials for this resource, if any.

#   tags

Tags is a map of key, value pairs.

#   username
#   def to_dict(self):
View Source
12034    def to_dict(self):
12035        return {
12036            'egress_filter': self.egress_filter,
12037            'healthy': self.healthy,
12038            'hostname': self.hostname,
12039            'id': self.id,
12040            'name': self.name,
12041            'password': self.password,
12042            'port': self.port,
12043            'port_override': self.port_override,
12044            'secret_store_id': self.secret_store_id,
12045            'tags': self.tags,
12046            'username': self.username,
12047        }
#  
@classmethod
def from_dict(cls, d):
View Source
12049    @classmethod
12050    def from_dict(cls, d):
12051        return cls(
12052            egress_filter=d.get('egress_filter'),
12053            healthy=d.get('healthy'),
12054            hostname=d.get('hostname'),
12055            id=d.get('id'),
12056            name=d.get('name'),
12057            password=d.get('password'),
12058            port=d.get('port'),
12059            port_override=d.get('port_override'),
12060            secret_store_id=d.get('secret_store_id'),
12061            tags=d.get('tags'),
12062            username=d.get('username'),
12063        )
#   class UpdateResponseMetadata:
View Source
12066class UpdateResponseMetadata:
12067    '''
12068     UpdateResponseMetadata is reserved for future use.
12069    '''
12070    __slots__ = []
12071
12072    def __init__(self, ):
12073        pass
12074
12075    def __repr__(self):
12076        return '<sdm.UpdateResponseMetadata ' + \
12077            '>'
12078
12079    def to_dict(self):
12080        return {}
12081
12082    @classmethod
12083    def from_dict(cls, d):
12084        return cls()

UpdateResponseMetadata is reserved for future use.

#   UpdateResponseMetadata()
View Source
12072    def __init__(self, ):
12073        pass
#   def to_dict(self):
View Source
12079    def to_dict(self):
12080        return {}
#  
@classmethod
def from_dict(cls, d):
View Source
12082    @classmethod
12083    def from_dict(cls, d):
12084        return cls()
#   class User:
View Source
12087class User:
12088    '''
12089     A User can connect to resources they are granted directly, or granted
12090     via roles.
12091    '''
12092    __slots__ = [
12093        'email',
12094        'first_name',
12095        'id',
12096        'last_name',
12097        'suspended',
12098        'tags',
12099    ]
12100
12101    def __init__(
12102        self,
12103        email=None,
12104        first_name=None,
12105        id=None,
12106        last_name=None,
12107        suspended=None,
12108        tags=None,
12109    ):
12110        self.email = email if email is not None else ''
12111        '''
12112         The User's email address. Must be unique.
12113        '''
12114        self.first_name = first_name if first_name is not None else ''
12115        '''
12116         The User's first name.
12117        '''
12118        self.id = id if id is not None else ''
12119        '''
12120         Unique identifier of the User.
12121        '''
12122        self.last_name = last_name if last_name is not None else ''
12123        '''
12124         The User's last name.
12125        '''
12126        self.suspended = suspended if suspended is not None else False
12127        '''
12128         The User's suspended state.
12129        '''
12130        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12131        '''
12132         Tags is a map of key, value pairs.
12133        '''
12134
12135    def __repr__(self):
12136        return '<sdm.User ' + \
12137            'email: ' + repr(self.email) + ' ' +\
12138            'first_name: ' + repr(self.first_name) + ' ' +\
12139            'id: ' + repr(self.id) + ' ' +\
12140            'last_name: ' + repr(self.last_name) + ' ' +\
12141            'suspended: ' + repr(self.suspended) + ' ' +\
12142            'tags: ' + repr(self.tags) + ' ' +\
12143            '>'
12144
12145    def to_dict(self):
12146        return {
12147            'email': self.email,
12148            'first_name': self.first_name,
12149            'id': self.id,
12150            'last_name': self.last_name,
12151            'suspended': self.suspended,
12152            'tags': self.tags,
12153        }
12154
12155    @classmethod
12156    def from_dict(cls, d):
12157        return cls(
12158            email=d.get('email'),
12159            first_name=d.get('first_name'),
12160            id=d.get('id'),
12161            last_name=d.get('last_name'),
12162            suspended=d.get('suspended'),
12163            tags=d.get('tags'),
12164        )

A User can connect to resources they are granted directly, or granted via roles.

#   User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None )
View Source
12101    def __init__(
12102        self,
12103        email=None,
12104        first_name=None,
12105        id=None,
12106        last_name=None,
12107        suspended=None,
12108        tags=None,
12109    ):
12110        self.email = email if email is not None else ''
12111        '''
12112         The User's email address. Must be unique.
12113        '''
12114        self.first_name = first_name if first_name is not None else ''
12115        '''
12116         The User's first name.
12117        '''
12118        self.id = id if id is not None else ''
12119        '''
12120         Unique identifier of the User.
12121        '''
12122        self.last_name = last_name if last_name is not None else ''
12123        '''
12124         The User's last name.
12125        '''
12126        self.suspended = suspended if suspended is not None else False
12127        '''
12128         The User's suspended state.
12129        '''
12130        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12131        '''
12132         Tags is a map of key, value pairs.
12133        '''
#   email

The User's email address. Must be unique.

#   first_name

The User's first name.

#   id

Unique identifier of the User.

#   last_name

The User's last name.

#   suspended

The User's suspended state.

#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
12145    def to_dict(self):
12146        return {
12147            'email': self.email,
12148            'first_name': self.first_name,
12149            'id': self.id,
12150            'last_name': self.last_name,
12151            'suspended': self.suspended,
12152            'tags': self.tags,
12153        }
#  
@classmethod
def from_dict(cls, d):
View Source
12155    @classmethod
12156    def from_dict(cls, d):
12157        return cls(
12158            email=d.get('email'),
12159            first_name=d.get('first_name'),
12160            id=d.get('id'),
12161            last_name=d.get('last_name'),
12162            suspended=d.get('suspended'),
12163            tags=d.get('tags'),
12164        )
#   class VaultAppRoleStore:
View Source
12167class VaultAppRoleStore:
12168    '''
12169
12170    '''
12171    __slots__ = [
12172        'id',
12173        'name',
12174        'namespace',
12175        'server_address',
12176        'tags',
12177    ]
12178
12179    def __init__(
12180        self,
12181        id=None,
12182        name=None,
12183        namespace=None,
12184        server_address=None,
12185        tags=None,
12186    ):
12187        self.id = id if id is not None else ''
12188        '''
12189         Unique identifier of the SecretStore.
12190        '''
12191        self.name = name if name is not None else ''
12192        '''
12193         Unique human-readable name of the SecretStore.
12194        '''
12195        self.namespace = namespace if namespace is not None else ''
12196        '''
12197
12198        '''
12199        self.server_address = server_address if server_address is not None else ''
12200        '''
12201
12202        '''
12203        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12204        '''
12205         Tags is a map of key, value pairs.
12206        '''
12207
12208    def __repr__(self):
12209        return '<sdm.VaultAppRoleStore ' + \
12210            'id: ' + repr(self.id) + ' ' +\
12211            'name: ' + repr(self.name) + ' ' +\
12212            'namespace: ' + repr(self.namespace) + ' ' +\
12213            'server_address: ' + repr(self.server_address) + ' ' +\
12214            'tags: ' + repr(self.tags) + ' ' +\
12215            '>'
12216
12217    def to_dict(self):
12218        return {
12219            'id': self.id,
12220            'name': self.name,
12221            'namespace': self.namespace,
12222            'server_address': self.server_address,
12223            'tags': self.tags,
12224        }
12225
12226    @classmethod
12227    def from_dict(cls, d):
12228        return cls(
12229            id=d.get('id'),
12230            name=d.get('name'),
12231            namespace=d.get('namespace'),
12232            server_address=d.get('server_address'),
12233            tags=d.get('tags'),
12234        )
#   VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
View Source
12179    def __init__(
12180        self,
12181        id=None,
12182        name=None,
12183        namespace=None,
12184        server_address=None,
12185        tags=None,
12186    ):
12187        self.id = id if id is not None else ''
12188        '''
12189         Unique identifier of the SecretStore.
12190        '''
12191        self.name = name if name is not None else ''
12192        '''
12193         Unique human-readable name of the SecretStore.
12194        '''
12195        self.namespace = namespace if namespace is not None else ''
12196        '''
12197
12198        '''
12199        self.server_address = server_address if server_address is not None else ''
12200        '''
12201
12202        '''
12203        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12204        '''
12205         Tags is a map of key, value pairs.
12206        '''
#   id

Unique identifier of the SecretStore.

#   name

Unique human-readable name of the SecretStore.

#   namespace
#   server_address
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
12217    def to_dict(self):
12218        return {
12219            'id': self.id,
12220            'name': self.name,
12221            'namespace': self.namespace,
12222            'server_address': self.server_address,
12223            'tags': self.tags,
12224        }
#  
@classmethod
def from_dict(cls, d):
View Source
12226    @classmethod
12227    def from_dict(cls, d):
12228        return cls(
12229            id=d.get('id'),
12230            name=d.get('name'),
12231            namespace=d.get('namespace'),
12232            server_address=d.get('server_address'),
12233            tags=d.get('tags'),
12234        )
#   class VaultTLSStore:
View Source
12237class VaultTLSStore:
12238    '''
12239
12240    '''
12241    __slots__ = [
12242        'ca_cert_path',
12243        'client_cert_path',
12244        'client_key_path',
12245        'id',
12246        'name',
12247        'namespace',
12248        'server_address',
12249        'tags',
12250    ]
12251
12252    def __init__(
12253        self,
12254        ca_cert_path=None,
12255        client_cert_path=None,
12256        client_key_path=None,
12257        id=None,
12258        name=None,
12259        namespace=None,
12260        server_address=None,
12261        tags=None,
12262    ):
12263        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12264        '''
12265
12266        '''
12267        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12268        '''
12269
12270        '''
12271        self.client_key_path = client_key_path if client_key_path is not None else ''
12272        '''
12273
12274        '''
12275        self.id = id if id is not None else ''
12276        '''
12277         Unique identifier of the SecretStore.
12278        '''
12279        self.name = name if name is not None else ''
12280        '''
12281         Unique human-readable name of the SecretStore.
12282        '''
12283        self.namespace = namespace if namespace is not None else ''
12284        '''
12285
12286        '''
12287        self.server_address = server_address if server_address is not None else ''
12288        '''
12289
12290        '''
12291        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12292        '''
12293         Tags is a map of key, value pairs.
12294        '''
12295
12296    def __repr__(self):
12297        return '<sdm.VaultTLSStore ' + \
12298            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12299            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12300            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12301            'id: ' + repr(self.id) + ' ' +\
12302            'name: ' + repr(self.name) + ' ' +\
12303            'namespace: ' + repr(self.namespace) + ' ' +\
12304            'server_address: ' + repr(self.server_address) + ' ' +\
12305            'tags: ' + repr(self.tags) + ' ' +\
12306            '>'
12307
12308    def to_dict(self):
12309        return {
12310            'ca_cert_path': self.ca_cert_path,
12311            'client_cert_path': self.client_cert_path,
12312            'client_key_path': self.client_key_path,
12313            'id': self.id,
12314            'name': self.name,
12315            'namespace': self.namespace,
12316            'server_address': self.server_address,
12317            'tags': self.tags,
12318        }
12319
12320    @classmethod
12321    def from_dict(cls, d):
12322        return cls(
12323            ca_cert_path=d.get('ca_cert_path'),
12324            client_cert_path=d.get('client_cert_path'),
12325            client_key_path=d.get('client_key_path'),
12326            id=d.get('id'),
12327            name=d.get('name'),
12328            namespace=d.get('namespace'),
12329            server_address=d.get('server_address'),
12330            tags=d.get('tags'),
12331        )
#   VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None )
View Source
12252    def __init__(
12253        self,
12254        ca_cert_path=None,
12255        client_cert_path=None,
12256        client_key_path=None,
12257        id=None,
12258        name=None,
12259        namespace=None,
12260        server_address=None,
12261        tags=None,
12262    ):
12263        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12264        '''
12265
12266        '''
12267        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12268        '''
12269
12270        '''
12271        self.client_key_path = client_key_path if client_key_path is not None else ''
12272        '''
12273
12274        '''
12275        self.id = id if id is not None else ''
12276        '''
12277         Unique identifier of the SecretStore.
12278        '''
12279        self.name = name if name is not None else ''
12280        '''
12281         Unique human-readable name of the SecretStore.
12282        '''
12283        self.namespace = namespace if namespace is not None else ''
12284        '''
12285
12286        '''
12287        self.server_address = server_address if server_address is not None else ''
12288        '''
12289
12290        '''
12291        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12292        '''
12293         Tags is a map of key, value pairs.
12294        '''
#   ca_cert_path
#   client_cert_path
#   client_key_path
#   id

Unique identifier of the SecretStore.

#   name

Unique human-readable name of the SecretStore.

#   namespace
#   server_address
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
12308    def to_dict(self):
12309        return {
12310            'ca_cert_path': self.ca_cert_path,
12311            'client_cert_path': self.client_cert_path,
12312            'client_key_path': self.client_key_path,
12313            'id': self.id,
12314            'name': self.name,
12315            'namespace': self.namespace,
12316            'server_address': self.server_address,
12317            'tags': self.tags,
12318        }
#  
@classmethod
def from_dict(cls, d):
View Source
12320    @classmethod
12321    def from_dict(cls, d):
12322        return cls(
12323            ca_cert_path=d.get('ca_cert_path'),
12324            client_cert_path=d.get('client_cert_path'),
12325            client_key_path=d.get('client_key_path'),
12326            id=d.get('id'),
12327            name=d.get('name'),
12328            namespace=d.get('namespace'),
12329            server_address=d.get('server_address'),
12330            tags=d.get('tags'),
12331        )
#   class VaultTokenStore:
View Source
12334class VaultTokenStore:
12335    '''
12336
12337    '''
12338    __slots__ = [
12339        'id',
12340        'name',
12341        'namespace',
12342        'server_address',
12343        'tags',
12344    ]
12345
12346    def __init__(
12347        self,
12348        id=None,
12349        name=None,
12350        namespace=None,
12351        server_address=None,
12352        tags=None,
12353    ):
12354        self.id = id if id is not None else ''
12355        '''
12356         Unique identifier of the SecretStore.
12357        '''
12358        self.name = name if name is not None else ''
12359        '''
12360         Unique human-readable name of the SecretStore.
12361        '''
12362        self.namespace = namespace if namespace is not None else ''
12363        '''
12364
12365        '''
12366        self.server_address = server_address if server_address is not None else ''
12367        '''
12368
12369        '''
12370        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12371        '''
12372         Tags is a map of key, value pairs.
12373        '''
12374
12375    def __repr__(self):
12376        return '<sdm.VaultTokenStore ' + \
12377            'id: ' + repr(self.id) + ' ' +\
12378            'name: ' + repr(self.name) + ' ' +\
12379            'namespace: ' + repr(self.namespace) + ' ' +\
12380            'server_address: ' + repr(self.server_address) + ' ' +\
12381            'tags: ' + repr(self.tags) + ' ' +\
12382            '>'
12383
12384    def to_dict(self):
12385        return {
12386            'id': self.id,
12387            'name': self.name,
12388            'namespace': self.namespace,
12389            'server_address': self.server_address,
12390            'tags': self.tags,
12391        }
12392
12393    @classmethod
12394    def from_dict(cls, d):
12395        return cls(
12396            id=d.get('id'),
12397            name=d.get('name'),
12398            namespace=d.get('namespace'),
12399            server_address=d.get('server_address'),
12400            tags=d.get('tags'),
12401        )
#   VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
View Source
12346    def __init__(
12347        self,
12348        id=None,
12349        name=None,
12350        namespace=None,
12351        server_address=None,
12352        tags=None,
12353    ):
12354        self.id = id if id is not None else ''
12355        '''
12356         Unique identifier of the SecretStore.
12357        '''
12358        self.name = name if name is not None else ''
12359        '''
12360         Unique human-readable name of the SecretStore.
12361        '''
12362        self.namespace = namespace if namespace is not None else ''
12363        '''
12364
12365        '''
12366        self.server_address = server_address if server_address is not None else ''
12367        '''
12368
12369        '''
12370        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12371        '''
12372         Tags is a map of key, value pairs.
12373        '''
#   id

Unique identifier of the SecretStore.

#   name

Unique human-readable name of the SecretStore.

#   namespace
#   server_address
#   tags

Tags is a map of key, value pairs.

#   def to_dict(self):
View Source
12384    def to_dict(self):
12385        return {
12386            'id': self.id,
12387            'name': self.name,
12388            'namespace': self.namespace,
12389            'server_address': self.server_address,
12390            'tags': self.tags,
12391        }
#  
@classmethod
def from_dict(cls, d):
View Source
12393    @classmethod
12394    def from_dict(cls, d):
12395        return cls(
12396            id=d.get('id'),
12397            name=d.get('name'),
12398            namespace=d.get('namespace'),
12399            server_address=d.get('server_address'),
12400            tags=d.get('tags'),
12401        )